refactor(cli): modularize CLI — extract parser, runner, report and main logic into dedicated files

benchmark_cherrypick/bin/main.dart

@@ -1,293 +1,5 @@
-import 'package:benchmark_cherrypick/benchmarks/universal_chain_benchmark.dart';
-import 'package:benchmark_cherrypick/benchmarks/universal_chain_async_benchmark.dart';
-import 'package:benchmark_cherrypick/di_adapters/cherrypick_adapter.dart';
-import 'package:benchmark_cherrypick/scenarios/universal_chain_module.dart';
-import 'package:args/args.dart';
-import 'dart:io';
-import 'dart:math';
-
-enum UniversalBenchmark {
-  registerSingleton,
-  chainSingleton,
-  chainFactory,
-  chainAsync,
-  named,
-  override,
-}
-
-UniversalScenario _toScenario(UniversalBenchmark b) {
-  switch (b) {
-    case UniversalBenchmark.registerSingleton:
-      return UniversalScenario.register;
-    case UniversalBenchmark.chainSingleton:
-      return UniversalScenario.chain;
-    case UniversalBenchmark.chainFactory:
-      return UniversalScenario.chain;
-    case UniversalBenchmark.chainAsync:
-      return UniversalScenario.asyncChain;
-    case UniversalBenchmark.named:
-      return UniversalScenario.named;
-    case UniversalBenchmark.override:
-      return UniversalScenario.override;
-  }
-}
-UniversalBindingMode _toMode(UniversalBenchmark b) {
-  switch (b) {
-    case UniversalBenchmark.registerSingleton:
-      return UniversalBindingMode.singletonStrategy;
-    case UniversalBenchmark.chainSingleton:
-      return UniversalBindingMode.singletonStrategy;
-    case UniversalBenchmark.chainFactory:
-      return UniversalBindingMode.factoryStrategy;
-    case UniversalBenchmark.chainAsync:
-      return UniversalBindingMode.asyncStrategy;
-    case UniversalBenchmark.named:
-      return UniversalBindingMode.singletonStrategy;
-    case UniversalBenchmark.override:
-      return UniversalBindingMode.singletonStrategy;
-  }
-}
-
-typedef SyncBench = UniversalChainBenchmark;
-typedef AsyncBench = UniversalChainAsyncBenchmark;
-
-class BenchmarkResult {
-  final List<num> timings;
-  final int memoryDiffKb;
-  final int deltaPeakKb;
-  final int peakRssKb;
-  BenchmarkResult({
-    required this.timings,
-    required this.memoryDiffKb,
-    required this.deltaPeakKb,
-    required this.peakRssKb,
-  });
-  factory BenchmarkResult.collect({
-    required List<num> timings,
-    required List<int> rssValues,
-    required int memBefore,
-  }) {
-    final memAfter = ProcessInfo.currentRss;
-    final memDiffKB = ((memAfter - memBefore) / 1024).round();
-    final peakRss = [...rssValues, memBefore].reduce(max);
-    final deltaPeakKb = ((peakRss - memBefore) / 1024).round();
-    return BenchmarkResult(
-      timings: timings,
-      memoryDiffKb: memDiffKB,
-      deltaPeakKb: deltaPeakKb,
-      peakRssKb: (peakRss / 1024).round(),
-    );
-  }
-}
-
-class BenchmarkRunner {
-  static Future<BenchmarkResult> runSync({
-    required SyncBench benchmark,
-    required int warmups,
-    required int repeats,
-  }) async {
-    final timings = <num>[];
-    final rssValues = <int>[];
-    for (int i = 0; i < warmups; i++) {
-      benchmark.setup();
-      benchmark.run();
-      benchmark.teardown();
-    }
-    final memBefore = ProcessInfo.currentRss;
-    for (int i = 0; i < repeats; i++) {
-      benchmark.setup();
-      final sw = Stopwatch()..start();
-      benchmark.run();
-      sw.stop();
-      timings.add(sw.elapsedMicroseconds);
-      rssValues.add(ProcessInfo.currentRss);
-      benchmark.teardown();
-    }
-    return BenchmarkResult.collect(
-      timings: timings,
-      rssValues: rssValues,
-      memBefore: memBefore,
-    );
-  }
-  static Future<BenchmarkResult> runAsync({
-    required AsyncBench benchmark,
-    required int warmups,
-    required int repeats,
-  }) async {
-    final timings = <num>[];
-    final rssValues = <int>[];
-    for (int i = 0; i < warmups; i++) {
-      await benchmark.setup();
-      await benchmark.run();
-      await benchmark.teardown();
-    }
-    final memBefore = ProcessInfo.currentRss;
-    for (int i = 0; i < repeats; i++) {
-      await benchmark.setup();
-      final sw = Stopwatch()..start();
-      await benchmark.run();
-      sw.stop();
-      timings.add(sw.elapsedMicroseconds);
-      rssValues.add(ProcessInfo.currentRss);
-      await benchmark.teardown();
-    }
-    return BenchmarkResult.collect(
-      timings: timings,
-      rssValues: rssValues,
-      memBefore: memBefore,
-    );
-  }
-}
-
-T parseEnum<T>(String value, List<T> values, T defaultValue) {
-  return values.firstWhere(
-    (v) => v.toString().split('.').last.toLowerCase() == value.toLowerCase(),
-    orElse: () => defaultValue,
-  );
-}
-
-/// --- Report Generation ---
-abstract class ReportGenerator {
-  String render(List<Map<String, dynamic>> results);
-  List<String> get keys;
-}
-class PrettyReport extends ReportGenerator {
-  @override
-  final List<String> keys = [
-    'benchmark','chainCount','nestingDepth','mean_us','median_us','stddev_us',
-    'min_us','max_us','trials','memory_diff_kb','delta_peak_kb','peak_rss_kb'
-  ];
-  @override
-  String render(List<Map<String, dynamic>> rows) {
-    final header = keys.join('\t');
-    final lines = rows.map((r) => keys.map((k) => (r[k] ?? '').toString()).join('\t')).toList();
-    return ([header] + lines).join('\n');
-  }
-}
-class CsvReport extends ReportGenerator {
-  @override
-  final List<String> keys = [
-    'benchmark','chainCount','nestingDepth','mean_us','median_us','stddev_us',
-    'min_us','max_us','trials','timings_us','memory_diff_kb','delta_peak_kb','peak_rss_kb'
-  ];
-  @override
-  String render(List<Map<String, dynamic>> rows) {
-    final header = keys.join(',');
-    final lines = rows.map((r) =>
-      keys.map((k) {
-        final v = r[k];
-        if (v is List) return '"${v.join(';')}"';
-        return (v ?? '').toString();
-      }).join(',')
-    ).toList();
-    return ([header] + lines).join('\n');
-  }
-}
-class JsonReport extends ReportGenerator {
-  @override
-  List<String> get keys => [];
-  @override
-  String render(List<Map<String, dynamic>> rows) {
-    return '[\n${rows.map((r) => '  $r').join(',\n')}\n]';
-  }
-}
+import 'package:benchmark_cherrypick/cli/benchmark_cli.dart';
 
 Future<void> main(List<String> args) async {
-  final parser = ArgParser()
-    ..addOption('benchmark', abbr: 'b', defaultsTo: 'chainSingleton')
-    ..addOption('chainCount', abbr: 'c', defaultsTo: '10')
-    ..addOption('nestingDepth', abbr: 'd', defaultsTo: '5')
-    ..addOption('repeat', abbr: 'r', defaultsTo: '2')
-    ..addOption('warmup', abbr: 'w', defaultsTo: '1')
-    ..addOption('format', abbr: 'f', defaultsTo: 'pretty')
-    ..addFlag('help', abbr: 'h', negatable: false, help: 'Show help');
-  final result = parser.parse(args);
-  if (result['help'] == true) {
-    print('UniversalChainBenchmark');
-    print(parser.usage);
-    print('Example:');
-    print('  dart run bin/main.dart --benchmark=chainFactory --chainCount=10 --nestingDepth=5 --format=csv');
-    return;
+  await BenchmarkCliRunner().run(args);
 }
-  final benchName = result['benchmark'] as String;
-  final isAll = benchName == 'all';
-  final List<UniversalBenchmark> allBenches = UniversalBenchmark.values;
-  final List<UniversalBenchmark> benchesToRun = isAll
-    ? allBenches
-    : [parseEnum(benchName, UniversalBenchmark.values, UniversalBenchmark.chainSingleton)];
-  final chainCounts = _parseIntList(result['chainCount'] as String);
-  final nestDepths = _parseIntList(result['nestingDepth'] as String);
-  final repeats = int.tryParse(result['repeat'] as String? ?? "") ?? 2;
-  final warmups = int.tryParse(result['warmup'] as String? ?? "") ?? 1;
-  final format = result['format'] as String;
-
-  final results = <Map<String, dynamic>>[];
-  for (final bench in benchesToRun) {
-    final scenario = _toScenario(bench);
-    final mode = _toMode(bench);
-    for (final c in chainCounts) {
-      for (final d in nestDepths) {
-        BenchmarkResult benchResult;
-        if (scenario == UniversalScenario.asyncChain) {
-          final di = CherrypickDIAdapter();
-          final benchAsync = UniversalChainAsyncBenchmark(
-            di,
-            chainCount: c,
-            nestingDepth: d,
-            mode: mode,
-          );
-          benchResult = await BenchmarkRunner.runAsync(
-            benchmark: benchAsync,
-            warmups: warmups,
-            repeats: repeats,
-          );
-        } else {
-          final di = CherrypickDIAdapter();
-          final benchSync = UniversalChainBenchmark(
-            di,
-            chainCount: c,
-            nestingDepth: d,
-            mode: mode,
-            scenario: scenario,
-          );
-          benchResult = await BenchmarkRunner.runSync(
-            benchmark: benchSync,
-            warmups: warmups,
-            repeats: repeats,
-          );
-        }
-        final timings = benchResult.timings;
-        timings.sort();
-        var mean = timings.reduce((a, b) => a + b) / timings.length;
-        var median = timings[timings.length ~/ 2];
-        var minVal = timings.first;
-        var maxVal = timings.last;
-        var stddev = sqrt(timings.map((x) => pow(x - mean, 2)).reduce((a, b) => a + b) / timings.length);
-        results.add({
-          'benchmark': 'Universal_$bench',
-          'chainCount': c,
-          'nestingDepth': d,
-          'mean_us': mean.round(),
-          'median_us': median.round(),
-          'stddev_us': stddev.round(),
-          'min_us': minVal.round(),
-          'max_us': maxVal.round(),
-          'trials': timings.length,
-          'timings_us': timings.map((t) => t.round()).toList(),
-          'memory_diff_kb': benchResult.memoryDiffKb,
-          'delta_peak_kb': benchResult.deltaPeakKb,
-          'peak_rss_kb': benchResult.peakRssKb,
-        });
-      }
-    }
-  }
-
-  final reportGenerators = {
-    'pretty': PrettyReport(),
-    'csv': CsvReport(),
-    'json': JsonReport(),
-  };
-  print(reportGenerators[format]?.render(results) ?? PrettyReport().render(results));
-}
-
-List<int> _parseIntList(String s) => s.split(',').map((e) => int.tryParse(e.trim()) ?? 0).where((x) => x > 0).toList();

benchmark_cherrypick/lib/cli/benchmark_cli.dart

@@ -0,0 +1,76 @@
+import 'dart:math';
+
+import '../scenarios/universal_chain_module.dart';
+import 'report/pretty_report.dart';
+import 'report/csv_report.dart';
+import 'report/json_report.dart';
+import 'parser.dart';
+import 'runner.dart';
+import 'package:benchmark_cherrypick/benchmarks/universal_chain_benchmark.dart';
+import 'package:benchmark_cherrypick/benchmarks/universal_chain_async_benchmark.dart';
+import 'package:benchmark_cherrypick/di_adapters/cherrypick_adapter.dart';
+
+class BenchmarkCliRunner {
+  Future<void> run(List<String> args) async {
+    final config = parseBenchmarkCli(args);
+    final results = <Map<String, dynamic>>[];
+    for (final bench in config.benchesToRun) {
+      final scenario = toScenario(bench);
+      final mode = toMode(bench);
+      for (final c in config.chainCounts) {
+        for (final d in config.nestDepths) {
+          BenchmarkResult benchResult;
+          if (scenario == UniversalScenario.asyncChain) {
+            final di = CherrypickDIAdapter();
+            final benchAsync = UniversalChainAsyncBenchmark(di,
+              chainCount: c, nestingDepth: d, mode: mode,
+            );
+            benchResult = await BenchmarkRunner.runAsync(
+              benchmark: benchAsync,
+              warmups: config.warmups,
+              repeats: config.repeats,
+            );
+          } else {
+            final di = CherrypickDIAdapter();
+            final benchSync = UniversalChainBenchmark(di,
+              chainCount: c, nestingDepth: d, mode: mode, scenario: scenario,
+            );
+            benchResult = await BenchmarkRunner.runSync(
+              benchmark: benchSync,
+              warmups: config.warmups,
+              repeats: config.repeats,
+            );
+          }
+          final timings = benchResult.timings;
+          timings.sort();
+          var mean = timings.reduce((a, b) => a + b) / timings.length;
+          var median = timings[timings.length ~/ 2];
+          var minVal = timings.first;
+          var maxVal = timings.last;
+          var stddev = timings.isEmpty ? 0 : sqrt(timings.map((x) => pow(x - mean, 2)).reduce((a, b) => a + b) / timings.length);
+          results.add({
+            'benchmark': 'Universal_$bench',
+            'chainCount': c,
+            'nestingDepth': d,
+            'mean_us': mean.round(),
+            'median_us': median.round(),
+            'stddev_us': stddev.round(),
+            'min_us': minVal.round(),
+            'max_us': maxVal.round(),
+            'trials': timings.length,
+            'timings_us': timings.map((t) => t.round()).toList(),
+            'memory_diff_kb': benchResult.memoryDiffKb,
+            'delta_peak_kb': benchResult.deltaPeakKb,
+            'peak_rss_kb': benchResult.peakRssKb,
+          });
+        }
+      }
+    }
+    final reportGenerators = {
+      'pretty': PrettyReport(),
+      'csv': CsvReport(),
+      'json': JsonReport(),
+    };
+    print(reportGenerators[config.format]?.render(results) ?? PrettyReport().render(results));
+  }
+}

benchmark_cherrypick/lib/cli/parser.dart

@@ -0,0 +1,104 @@
+import 'dart:io';
+
+import 'package:args/args.dart';
+import 'package:benchmark_cherrypick/scenarios/universal_chain_module.dart';
+
+enum UniversalBenchmark {
+  registerSingleton,
+  chainSingleton,
+  chainFactory,
+  chainAsync,
+  named,
+  override,
+}
+
+UniversalScenario toScenario(UniversalBenchmark b) {
+  switch (b) {
+    case UniversalBenchmark.registerSingleton:
+      return UniversalScenario.register;
+    case UniversalBenchmark.chainSingleton:
+      return UniversalScenario.chain;
+    case UniversalBenchmark.chainFactory:
+      return UniversalScenario.chain;
+    case UniversalBenchmark.chainAsync:
+      return UniversalScenario.asyncChain;
+    case UniversalBenchmark.named:
+      return UniversalScenario.named;
+    case UniversalBenchmark.override:
+      return UniversalScenario.override;
+  }
+}
+
+UniversalBindingMode toMode(UniversalBenchmark b) {
+  switch (b) {
+    case UniversalBenchmark.registerSingleton:
+      return UniversalBindingMode.singletonStrategy;
+    case UniversalBenchmark.chainSingleton:
+      return UniversalBindingMode.singletonStrategy;
+    case UniversalBenchmark.chainFactory:
+      return UniversalBindingMode.factoryStrategy;
+    case UniversalBenchmark.chainAsync:
+      return UniversalBindingMode.asyncStrategy;
+    case UniversalBenchmark.named:
+      return UniversalBindingMode.singletonStrategy;
+    case UniversalBenchmark.override:
+      return UniversalBindingMode.singletonStrategy;
+  }
+}
+
+T parseEnum<T>(String value, List<T> values, T defaultValue) {
+  return values.firstWhere(
+    (v) => v.toString().split('.').last.toLowerCase() == value.toLowerCase(),
+    orElse: () => defaultValue,
+  );
+}
+
+List<int> parseIntList(String s) =>
+    s.split(',').map((e) => int.tryParse(e.trim()) ?? 0).where((x) => x > 0).toList();
+
+class BenchmarkCliConfig {
+  final List<UniversalBenchmark> benchesToRun;
+  final List<int> chainCounts;
+  final List<int> nestDepths;
+  final int repeats;
+  final int warmups;
+  final String format;
+  BenchmarkCliConfig({
+    required this.benchesToRun,
+    required this.chainCounts,
+    required this.nestDepths,
+    required this.repeats,
+    required this.warmups,
+    required this.format,
+  });
+}
+
+BenchmarkCliConfig parseBenchmarkCli(List<String> args) {
+  final parser = ArgParser()
+    ..addOption('benchmark', abbr: 'b', defaultsTo: 'chainSingleton')
+    ..addOption('chainCount', abbr: 'c', defaultsTo: '10')
+    ..addOption('nestingDepth', abbr: 'd', defaultsTo: '5')
+    ..addOption('repeat', abbr: 'r', defaultsTo: '2')
+    ..addOption('warmup', abbr: 'w', defaultsTo: '1')
+    ..addOption('format', abbr: 'f', defaultsTo: 'pretty')
+    ..addFlag('help', abbr: 'h', negatable: false, help: 'Show help');
+  final result = parser.parse(args);
+  if (result['help'] == true) {
+    print(parser.usage);
+    exit(0);
+  }
+  final benchName = result['benchmark'] as String;
+  final isAll = benchName == 'all';
+  final allBenches = UniversalBenchmark.values;
+  final benchesToRun = isAll
+      ? allBenches
+      : [parseEnum(benchName, allBenches, UniversalBenchmark.chainSingleton)];
+  return BenchmarkCliConfig(
+    benchesToRun: benchesToRun,
+    chainCounts: parseIntList(result['chainCount'] as String),
+    nestDepths: parseIntList(result['nestingDepth'] as String),
+    repeats: int.tryParse(result['repeat'] as String? ?? "") ?? 2,
+    warmups: int.tryParse(result['warmup'] as String? ?? "") ?? 1,
+    format: result['format'] as String,
+  );
+}

benchmark_cherrypick/lib/cli/report/csv_report.dart

@@ -0,0 +1,21 @@
+import 'report_generator.dart';
+
+class CsvReport extends ReportGenerator {
+  @override
+  final List<String> keys = [
+    'benchmark','chainCount','nestingDepth','mean_us','median_us','stddev_us',
+    'min_us','max_us','trials','timings_us','memory_diff_kb','delta_peak_kb','peak_rss_kb'
+  ];
+  @override
+  String render(List<Map<String, dynamic>> rows) {
+    final header = keys.join(',');
+    final lines = rows.map((r) =>
+      keys.map((k) {
+        final v = r[k];
+        if (v is List) return '"${v.join(';')}"';
+        return (v ?? '').toString();
+      }).join(',')
+    ).toList();
+    return ([header] + lines).join('\n');
+  }
+}

benchmark_cherrypick/lib/cli/report/json_report.dart

@@ -0,0 +1,10 @@
+import 'report_generator.dart';
+
+class JsonReport extends ReportGenerator {
+  @override
+  List<String> get keys => [];
+  @override
+  String render(List<Map<String, dynamic>> rows) {
+    return '[\n${rows.map((r) => '  $r').join(',\n')}\n]';
+  }
+}

benchmark_cherrypick/lib/cli/report/pretty_report.dart

@@ -0,0 +1,15 @@
+import 'report_generator.dart';
+
+class PrettyReport extends ReportGenerator {
+  @override
+  final List<String> keys = [
+    'benchmark','chainCount','nestingDepth','mean_us','median_us','stddev_us',
+    'min_us','max_us','trials','memory_diff_kb','delta_peak_kb','peak_rss_kb'
+  ];
+  @override
+  String render(List<Map<String, dynamic>> rows) {
+    final header = keys.join('\t');
+    final lines = rows.map((r) => keys.map((k) => (r[k] ?? '').toString()).join('\t')).toList();
+    return ([header] + lines).join('\n');
+  }
+}

benchmark_cherrypick/lib/cli/report/report_generator.dart

@@ -0,0 +1,4 @@
+abstract class ReportGenerator {
+  String render(List<Map<String, dynamic>> results);
+  List<String> get keys;
+}

benchmark_cherrypick/lib/cli/runner.dart

@@ -0,0 +1,85 @@
+import 'dart:io';
+import 'dart:math';
+import 'package:benchmark_cherrypick/benchmarks/universal_chain_benchmark.dart';
+import 'package:benchmark_cherrypick/benchmarks/universal_chain_async_benchmark.dart';
+
+class BenchmarkResult {
+  final List<num> timings;
+  final int memoryDiffKb;
+  final int deltaPeakKb;
+  final int peakRssKb;
+  BenchmarkResult({
+    required this.timings,
+    required this.memoryDiffKb,
+    required this.deltaPeakKb,
+    required this.peakRssKb,
+  });
+  factory BenchmarkResult.collect({
+    required List<num> timings,
+    required List<int> rssValues,
+    required int memBefore,
+  }) {
+    final memAfter = ProcessInfo.currentRss;
+    final memDiffKB = ((memAfter - memBefore) / 1024).round();
+    final peakRss = [...rssValues, memBefore].reduce(max);
+    final deltaPeakKb = ((peakRss - memBefore) / 1024).round();
+    return BenchmarkResult(
+      timings: timings,
+      memoryDiffKb: memDiffKB,
+      deltaPeakKb: deltaPeakKb,
+      peakRssKb: (peakRss / 1024).round(),
+    );
+  }
+}
+
+class BenchmarkRunner {
+  static Future<BenchmarkResult> runSync({
+    required UniversalChainBenchmark benchmark,
+    required int warmups,
+    required int repeats,
+  }) async {
+    final timings = <num>[];
+    final rssValues = <int>[];
+    for (int i = 0; i < warmups; i++) {
+      benchmark.setup();
+      benchmark.run();
+      benchmark.teardown();
+    }
+    final memBefore = ProcessInfo.currentRss;
+    for (int i = 0; i < repeats; i++) {
+      benchmark.setup();
+      final sw = Stopwatch()..start();
+      benchmark.run();
+      sw.stop();
+      timings.add(sw.elapsedMicroseconds);
+      rssValues.add(ProcessInfo.currentRss);
+      benchmark.teardown();
+    }
+    return BenchmarkResult.collect(timings: timings, rssValues: rssValues, memBefore: memBefore);
+  }
+
+  static Future<BenchmarkResult> runAsync({
+    required UniversalChainAsyncBenchmark benchmark,
+    required int warmups,
+    required int repeats,
+  }) async {
+    final timings = <num>[];
+    final rssValues = <int>[];
+    for (int i = 0; i < warmups; i++) {
+      await benchmark.setup();
+      await benchmark.run();
+      await benchmark.teardown();
+    }
+    final memBefore = ProcessInfo.currentRss;
+    for (int i = 0; i < repeats; i++) {
+      await benchmark.setup();
+      final sw = Stopwatch()..start();
+      await benchmark.run();
+      sw.stop();
+      timings.add(sw.elapsedMicroseconds);
+      rssValues.add(ProcessInfo.currentRss);
+      await benchmark.teardown();
+    }
+    return BenchmarkResult.collect(timings: timings, rssValues: rssValues, memBefore: memBefore);
+  }
+}