style: reformat codebase using melos format

Applied consistent code formatting across all packages using \$ melos format
  └> dart format .
     └> RUNNING (in 8 packages)

--------------------------------------------------------------------------------
benchmark_di:
Formatted 18 files (0 changed) in 0.30 seconds.
benchmark_di: SUCCESS
--------------------------------------------------------------------------------
cherrypick:
Formatted 24 files (0 changed) in 0.34 seconds.
cherrypick: SUCCESS
--------------------------------------------------------------------------------
cherrypick_annotations:
Formatted 11 files (0 changed) in 0.14 seconds.
cherrypick_annotations: SUCCESS
--------------------------------------------------------------------------------
cherrypick_flutter:
Formatted 3 files (0 changed) in 0.15 seconds.
cherrypick_flutter: SUCCESS
--------------------------------------------------------------------------------
cherrypick_generator:
Formatted 17 files (0 changed) in 0.27 seconds.
cherrypick_generator: SUCCESS
--------------------------------------------------------------------------------
client_app:
Formatted 4 files (0 changed) in 0.14 seconds.
client_app: SUCCESS
--------------------------------------------------------------------------------
postly:
Formatted lib/router/app_router.gr.dart
Formatted 23 files (1 changed) in 0.33 seconds.
postly: SUCCESS
--------------------------------------------------------------------------------
talker_cherrypick_logger:
Formatted 4 files (0 changed) in 0.18 seconds.
talker_cherrypick_logger: SUCCESS
--------------------------------------------------------------------------------

$ melos format
  └> dart format .
     └> SUCCESS. No functional or logic changes included.

cherrypick/example/bin/main.dart

@@ -47,19 +47,19 @@ class FeatureModule extends Module {
 
 Future<void> main() async {
   try {
-  final scope = CherryPick.openRootScope().installModules([AppModule()]);
+    final scope = CherryPick.openRootScope().installModules([AppModule()]);
 
     final subScope = scope
         .openSubScope("featureScope")
         .installModules([FeatureModule(isMock: true)]);
 
-  // Asynchronous instance resolution
-  final dataBloc = await subScope.resolveAsync<DataBloc>();
-  dataBloc.data.listen(
-    (d) => print('Received data: $d'),
-    onError: (e) => print('Error: $e'),
-    onDone: () => print('DONE'),
-  );
+    // Asynchronous instance resolution
+    final dataBloc = await subScope.resolveAsync<DataBloc>();
+    dataBloc.data.listen(
+      (d) => print('Received data: $d'),
+      onError: (e) => print('Error: $e'),
+      onDone: () => print('DONE'),
+    );
 
     await dataBloc.fetchData();
   } catch (e) {

cherrypick/example/cherrypick_helper_example.dart

@@ -8,7 +8,7 @@ class DatabaseService {
 class ApiService {
   final DatabaseService database;
   ApiService(this.database);
-  
+
   void fetchData() {
     database.connect();
     print('📡 Fetching data via API');
@@ -18,7 +18,7 @@ class ApiService {
 class UserService {
   final ApiService apiService;
   UserService(this.apiService);
-  
+
   void getUser(String id) {
     apiService.fetchData();
     print('👤 Fetching user: $id');
@@ -36,18 +36,16 @@ class DatabaseModule extends Module {
 class ApiModule extends Module {
   @override
   void builder(Scope currentScope) {
-    bind<ApiService>().toProvide(() => ApiService(
-      currentScope.resolve<DatabaseService>()
-    ));
+    bind<ApiService>()
+        .toProvide(() => ApiService(currentScope.resolve<DatabaseService>()));
   }
 }
 
 class UserModule extends Module {
   @override
   void builder(Scope currentScope) {
-    bind<UserService>().toProvide(() => UserService(
-      currentScope.resolve<ApiService>()
-    ));
+    bind<UserService>()
+        .toProvide(() => UserService(currentScope.resolve<ApiService>()));
   }
 }
 
@@ -65,74 +63,75 @@ class CircularServiceB {
 class CircularModuleA extends Module {
   @override
   void builder(Scope currentScope) {
-    bind<CircularServiceA>().toProvide(() => CircularServiceA(
-      currentScope.resolve<CircularServiceB>()
-    ));
+    bind<CircularServiceA>().toProvide(
+        () => CircularServiceA(currentScope.resolve<CircularServiceB>()));
   }
 }
 
 class CircularModuleB extends Module {
   @override
   void builder(Scope currentScope) {
-    bind<CircularServiceB>().toProvide(() => CircularServiceB(
-      currentScope.resolve<CircularServiceA>()
-    ));
+    bind<CircularServiceB>().toProvide(
+        () => CircularServiceB(currentScope.resolve<CircularServiceA>()));
   }
 }
 
 void main() {
   print('=== Improved CherryPick Helper Demonstration ===\n');
-  
+
   // Example 1: Global enabling of cycle detection
   print('1. Globally enable cycle detection:');
-  
+
   CherryPick.enableGlobalCycleDetection();
-  print('✅ Global cycle detection enabled: ${CherryPick.isGlobalCycleDetectionEnabled}');
-  
+  print(
+      '✅ Global cycle detection enabled: ${CherryPick.isGlobalCycleDetectionEnabled}');
+
   // All new scopes will automatically have cycle detection enabled
   final globalScope = CherryPick.openRootScope();
-  print('✅ Root scope has cycle detection enabled: ${globalScope.isCycleDetectionEnabled}');
-  
+  print(
+      '✅ Root scope has cycle detection enabled: ${globalScope.isCycleDetectionEnabled}');
+
   // Install modules without circular dependencies
   globalScope.installModules([
     DatabaseModule(),
     ApiModule(),
     UserModule(),
   ]);
-  
+
   final userService = globalScope.resolve<UserService>();
   userService.getUser('user123');
   print('');
-  
+
   // Example 2: Safe scope creation
   print('2. Creating safe scopes:');
-  
+
   CherryPick.closeRootScope(); // Закрываем предыдущий скоуп
   CherryPick.disableGlobalCycleDetection(); // Отключаем глобальную настройку
-  
+
   // Создаем безопасный скоуп (с автоматически включенным обнаружением)
   final safeScope = CherryPick.openSafeRootScope();
-  print('✅ Safe scope created with cycle detection: ${safeScope.isCycleDetectionEnabled}');
-  
+  print(
+      '✅ Safe scope created with cycle detection: ${safeScope.isCycleDetectionEnabled}');
+
   safeScope.installModules([
     DatabaseModule(),
     ApiModule(),
     UserModule(),
   ]);
-  
+
   final safeUserService = safeScope.resolve<UserService>();
   safeUserService.getUser('safe_user456');
   print('');
-  
+
   // Example 3: Detecting cycles
   print('3. Detecting circular dependencies:');
-  
+
   final cyclicScope = CherryPick.openSafeRootScope();
   cyclicScope.installModules([
     CircularModuleA(),
     CircularModuleB(),
   ]);
-  
+
   try {
     cyclicScope.resolve<CircularServiceA>();
     print('❌ This should not be executed');
@@ -144,87 +143,96 @@ void main() {
     }
   }
   print('');
-  
+
   // Example 4: Managing detection for specific scopes
   print('4. Managing detection for specific scopes:');
-  
+
   CherryPick.closeRootScope();
-  
+
   // Создаем скоуп без обнаружения
   // ignore: unused_local_variable
   final specificScope = CherryPick.openRootScope();
-  print('   Detection in root scope: ${CherryPick.isCycleDetectionEnabledForScope()}');
-  
+  print(
+      '   Detection in root scope: ${CherryPick.isCycleDetectionEnabledForScope()}');
+
   // Включаем обнаружение для конкретного скоупа
   CherryPick.enableCycleDetectionForScope();
-  print('✅ Detection enabled for root scope: ${CherryPick.isCycleDetectionEnabledForScope()}');
-  
+  print(
+      '✅ Detection enabled for root scope: ${CherryPick.isCycleDetectionEnabledForScope()}');
+
   // Создаем дочерний скоуп
   // ignore: unused_local_variable
   final featureScope = CherryPick.openScope(scopeName: 'feature.auth');
-  print('   Detection in feature.auth scope: ${CherryPick.isCycleDetectionEnabledForScope(scopeName: 'feature.auth')}');
-  
+  print(
+      '   Detection in feature.auth scope: ${CherryPick.isCycleDetectionEnabledForScope(scopeName: 'feature.auth')}');
+
   // Включаем обнаружение для дочернего скоупа
   CherryPick.enableCycleDetectionForScope(scopeName: 'feature.auth');
-  print('✅ Detection enabled for feature.auth scope: ${CherryPick.isCycleDetectionEnabledForScope(scopeName: 'feature.auth')}');
+  print(
+      '✅ Detection enabled for feature.auth scope: ${CherryPick.isCycleDetectionEnabledForScope(scopeName: 'feature.auth')}');
   print('');
-  
+
   // Example 5: Creating safe child scopes
   print('5. Creating safe child scopes:');
-  
-  final safeFeatureScope = CherryPick.openSafeScope(scopeName: 'feature.payments');
-  print('✅ Safe feature scope created: ${safeFeatureScope.isCycleDetectionEnabled}');
-  
+
+  final safeFeatureScope =
+      CherryPick.openSafeScope(scopeName: 'feature.payments');
+  print(
+      '✅ Safe feature scope created: ${safeFeatureScope.isCycleDetectionEnabled}');
+
   // You can create a complex hierarchy of scopes
-  final complexScope = CherryPick.openSafeScope(scopeName: 'app.feature.auth.login');
+  final complexScope =
+      CherryPick.openSafeScope(scopeName: 'app.feature.auth.login');
   print('✅ Complex scope created: ${complexScope.isCycleDetectionEnabled}');
   print('');
-  
+
   // Example 6: Tracking resolution chains
   print('6. Tracking dependency resolution chains:');
-  
+
   final trackingScope = CherryPick.openSafeRootScope();
   trackingScope.installModules([
     DatabaseModule(),
     ApiModule(),
     UserModule(),
   ]);
-  
+
   print('   Chain before resolve: ${CherryPick.getCurrentResolutionChain()}');
-  
+
   // The chain is populated during resolution, but cleared after completion
   // ignore: unused_local_variable
   final trackedUserService = trackingScope.resolve<UserService>();
   print('   Chain after resolve: ${CherryPick.getCurrentResolutionChain()}');
   print('');
-  
+
   // Example 7: Usage recommendations
   print('7. Recommended usage:');
   print('');
-  
+
   print('🔧 Development mode:');
   print('   CherryPick.enableGlobalCycleDetection(); // Enable globally');
   print('   or');
   print('   final scope = CherryPick.openSafeRootScope(); // Safe scope');
   print('');
-  
+
   print('🚀 Production mode:');
-  print('   CherryPick.disableGlobalCycleDetection(); // Disable for performance');
+  print(
+      '   CherryPick.disableGlobalCycleDetection(); // Disable for performance');
   print('   final scope = CherryPick.openRootScope(); // Regular scope');
   print('');
-  
+
   print('🧪 Testing:');
   print('   setUp(() => CherryPick.enableGlobalCycleDetection());');
   print('   tearDown(() => CherryPick.closeRootScope());');
   print('');
-  
+
   print('🎯 Feature-specific:');
-  print('   CherryPick.enableCycleDetectionForScope(scopeName: "feature.critical");');
+  print(
+      '   CherryPick.enableCycleDetectionForScope(scopeName: "feature.critical");');
   print('   // Enable only for critical features');
-  
+
   // Cleanup
   CherryPick.closeRootScope();
   CherryPick.disableGlobalCycleDetection();
-  
+
   print('\n=== Demonstration complete ===');
 }

cherrypick/example/cycle_detection_example.dart

@@ -3,9 +3,9 @@ import 'package:cherrypick/cherrypick.dart';
 // Пример сервисов с циклической зависимостью
 class UserService {
   final OrderService orderService;
-  
+
   UserService(this.orderService);
-  
+
   void createUser(String name) {
     print('Creating user: $name');
     // Пытаемся получить заказы пользователя, что создает циклическую зависимость
@@ -15,9 +15,9 @@ class UserService {
 
 class OrderService {
   final UserService userService;
-  
+
   OrderService(this.userService);
-  
+
   void getOrdersForUser(String userName) {
     print('Getting orders for user: $userName');
     // Пытаемся получить информацию о пользователе, что создает циклическую зависимость
@@ -29,18 +29,16 @@ class OrderService {
 class UserModule extends Module {
   @override
   void builder(Scope currentScope) {
-    bind<UserService>().toProvide(() => UserService(
-      currentScope.resolve<OrderService>()
-    ));
+    bind<UserService>()
+        .toProvide(() => UserService(currentScope.resolve<OrderService>()));
   }
 }
 
 class OrderModule extends Module {
   @override
   void builder(Scope currentScope) {
-    bind<OrderService>().toProvide(() => OrderService(
-      currentScope.resolve<UserService>()
-    ));
+    bind<OrderService>()
+        .toProvide(() => OrderService(currentScope.resolve<UserService>()));
   }
 }
 
@@ -49,7 +47,7 @@ class UserRepository {
   void createUser(String name) {
     print('Creating user in repository: $name');
   }
-  
+
   String getUserInfo(String name) {
     return 'User info for: $name';
   }
@@ -59,7 +57,7 @@ class OrderRepository {
   void createOrder(String orderId, String userName) {
     print('Creating order $orderId for user: $userName');
   }
-  
+
   List<String> getOrdersForUser(String userName) {
     return ['order1', 'order2', 'order3'];
   }
@@ -67,13 +65,13 @@ class OrderRepository {
 
 class ImprovedUserService {
   final UserRepository userRepository;
-  
+
   ImprovedUserService(this.userRepository);
-  
+
   void createUser(String name) {
     userRepository.createUser(name);
   }
-  
+
   String getUserInfo(String name) {
     return userRepository.getUserInfo(name);
   }
@@ -82,17 +80,17 @@ class ImprovedUserService {
 class ImprovedOrderService {
   final OrderRepository orderRepository;
   final ImprovedUserService userService;
-  
+
   ImprovedOrderService(this.orderRepository, this.userService);
-  
+
   void createOrder(String orderId, String userName) {
     // Проверяем, что пользователь существует
     final userInfo = userService.getUserInfo(userName);
     print('User exists: $userInfo');
-    
+
     orderRepository.createOrder(orderId, userName);
   }
-  
+
   List<String> getOrdersForUser(String userName) {
     return orderRepository.getOrdersForUser(userName);
   }
@@ -103,9 +101,8 @@ class ImprovedUserModule extends Module {
   @override
   void builder(Scope currentScope) {
     bind<UserRepository>().singleton().toProvide(() => UserRepository());
-    bind<ImprovedUserService>().toProvide(() => ImprovedUserService(
-      currentScope.resolve<UserRepository>()
-    ));
+    bind<ImprovedUserService>().toProvide(
+        () => ImprovedUserService(currentScope.resolve<UserRepository>()));
   }
 }
 
@@ -114,81 +111,80 @@ class ImprovedOrderModule extends Module {
   void builder(Scope currentScope) {
     bind<OrderRepository>().singleton().toProvide(() => OrderRepository());
     bind<ImprovedOrderService>().toProvide(() => ImprovedOrderService(
-      currentScope.resolve<OrderRepository>(),
-      currentScope.resolve<ImprovedUserService>()
-    ));
+        currentScope.resolve<OrderRepository>(),
+        currentScope.resolve<ImprovedUserService>()));
   }
 }
 
 void main() {
   print('=== Circular Dependency Detection Example ===\n');
-  
+
   // Example 1: Demonstrate circular dependency
   print('1. Attempt to create a scope with circular dependencies:');
   try {
     final scope = CherryPick.openRootScope();
-    scope.enableCycleDetection(); // Включаем обнаружение циклических зависимостей
-    
+    scope
+        .enableCycleDetection(); // Включаем обнаружение циклических зависимостей
+
     scope.installModules([
       UserModule(),
       OrderModule(),
     ]);
-    
+
     // Это должно выбросить CircularDependencyException
     final userService = scope.resolve<UserService>();
     print('UserService created: $userService');
   } catch (e) {
     print('❌ Circular dependency detected: $e\n');
   }
-  
+
   // Example 2: Without circular dependency detection (dangerous!)
   print('2. Same code without circular dependency detection:');
   try {
     final scope = CherryPick.openRootScope();
     // НЕ включаем обнаружение циклических зависимостей
-    
+
     scope.installModules([
       UserModule(),
       OrderModule(),
     ]);
-    
+
     // Это приведет к StackOverflowError при попытке использования
     final userService = scope.resolve<UserService>();
     print('UserService создан: $userService');
-    
+
     // Попытка использовать сервис приведет к бесконечной рекурсии
     // userService.createUser('John'); // Раскомментируйте для демонстрации StackOverflow
     print('⚠️  UserService created, but using it will cause StackOverflow\n');
   } catch (e) {
     print('❌ Error: $e\n');
   }
-  
+
   // Example 3: Correct architecture without circular dependencies
   print('3. Correct architecture without circular dependencies:');
   try {
     final scope = CherryPick.openRootScope();
     scope.enableCycleDetection(); // Включаем для безопасности
-    
+
     scope.installModules([
       ImprovedUserModule(),
       ImprovedOrderModule(),
     ]);
-    
+
     final userService = scope.resolve<ImprovedUserService>();
     final orderService = scope.resolve<ImprovedOrderService>();
-    
+
     print('✅ Services created successfully');
-    
+
     // Демонстрация работы
     userService.createUser('John');
     orderService.createOrder('ORD-001', 'John');
     final orders = orderService.getOrdersForUser('John');
     print('✅ Orders for user John: $orders');
-    
   } catch (e) {
     print('❌ Error: $e');
   }
-  
+
   print('\n=== Recommendations ===');
   print('1. Always enable circular dependency detection in development mode.');
   print('2. Use repositories and services to separate concerns.');