v1.5.0

Add nylo test, nylo clean platform flags, and nylo self-update commands.

Author: agordn52

CHANGELOG.md

@@ -1,3 +1,23 @@
+## [1.5.0] - 2026-03-28
+
+### Added
+- `nylo self-update` command: updates nylo_installer to the latest version from pub.dev
+- Automatic update detection: shows a styled banner after any command when a newer version is available
+- Version check caching in `~/.nylo/version_cache.json` with 24-hour TTL
+- 2-second HTTP timeout for version checks — network failures are silently ignored
+- `nylo test` command: format and run Flutter tests with pretty JSON output, per-test timing, and aggregated pass/fail summary
+- `nylo test` flags: `--no-format`, `--filter=<pattern>`, `--coverage`, `--path=<dir>`
+- `nylo clean` platform-specific deep cleaning with `--ios`, `--android`, and `--all` flags
+- iOS deep clean: removes Pods, .symlinks, Podfile.lock and re-runs `pod install --repo-update`
+- Android deep clean: runs `gradlew clean`
+- Platform directory validation before attempting platform-specific cleans
+- Comprehensive tests for `CleanCommand` and `TestCommand`
+
+### Changed
+- `CleanCommand.run()` now accepts optional arguments for flag parsing
+- CLI argument parser uses `allowTrailingOptions: false` for correct subcommand argument routing
+- Updated help text with all new command flags and usage examples
+
 ## [1.4.0] - 2026-02-14
 
 ### Added

README.md

@@ -17,6 +17,14 @@ Commands:
   new <project_name>    Create a new Nylo project
   init                  Set up the Metro CLI alias
   clean                 Run flutter clean and flutter pub get
+    --ios               Deep clean iOS (remove Pods, re-run pod install)
+    --android           Deep clean Android (run gradlew clean)
+    --all               Deep clean both iOS and Android
+  test                  Format and run Flutter tests
+    --no-format         Skip formatting before running tests
+    --filter=<pattern>  Filter tests by name
+    --coverage          Collect code coverage
+    --path=<dir>        Test directory path (default: test)
 
 Options:
   -h, --help            Show usage information
@@ -62,6 +70,32 @@ This runs:
 1. `flutter clean` - Removes build artifacts
 2. `flutter pub get` - Reinstalls dependencies
 
+Use platform flags for deep cleaning:
+
+```bash
+nylo clean --ios       # Deep clean iOS (removes Pods, .symlinks, Podfile.lock, re-runs pod install)
+nylo clean --android   # Deep clean Android (runs gradlew clean)
+nylo clean --all       # Deep clean both iOS and Android
+```
+
+### `nylo test`
+
+Format and run Flutter tests with pretty output:
+
+```bash
+nylo test
+```
+
+Options:
+
+```bash
+nylo test --no-format              # Skip formatting before running tests
+nylo test --filter "login"         # Filter tests by name
+nylo test --coverage               # Collect code coverage
+nylo test --path integration_test  # Specify test directory
+nylo test --filter "auth" --coverage
+```
+
 ## Metro CLI
 
 Once Metro is set up via `nylo init`, you can generate files for your Nylo project:

bin/nylo.dart

@@ -5,11 +5,14 @@ import 'package:args/args.dart';
 import 'package:nylo_installer/src/commands/clean_command.dart';
 import 'package:nylo_installer/src/commands/init_command.dart';
 import 'package:nylo_installer/src/commands/new_command.dart';
+import 'package:nylo_installer/src/commands/self_update_command.dart';
+import 'package:nylo_installer/src/commands/test_command.dart';
 import 'package:nylo_installer/src/console/console.dart';
 import 'package:nylo_installer/src/constants.dart';
+import 'package:nylo_installer/src/utils/version_checker.dart';
 
 void main(List<String> arguments) async {
-  final parser = ArgParser()
+  final parser = ArgParser(allowTrailingOptions: false)
     ..addFlag('help',
         abbr: 'h', negatable: false, help: 'Show usage information')
     ..addFlag('version', abbr: 'v', negatable: false, help: 'Show version');
@@ -48,13 +51,31 @@ void main(List<String> arguments) async {
         await InitCommand().run();
         break;
       case 'clean':
-        await CleanCommand().run();
+        final cleanArgs =
+            results.rest.length > 1 ? results.rest.sublist(1) : <String>[];
+        await CleanCommand().run(cleanArgs);
+        break;
+      case 'test':
+        final testArgs =
+            results.rest.length > 1 ? results.rest.sublist(1) : <String>[];
+        await TestCommand().run(testArgs);
+        break;
+      case 'self-update':
+        await SelfUpdateCommand().run();
         break;
       default:
         NyloConsole.writeError('Unknown command: $command');
         _printUsage();
         exit(1);
     }
+
+    // Check for updates after command completes (skip for self-update)
+    if (command != 'self-update') {
+      final updateInfo = await VersionChecker().checkForUpdate();
+      if (updateInfo != null) {
+        VersionChecker.printUpdateBanner(updateInfo);
+      }
+    }
   } on FormatException catch (e) {
     NyloConsole.writeError('Error: ${e.message}');
     _printUsage();
@@ -73,6 +94,15 @@ void _printUsage() {
     new <project_name>    Create a new Nylo project
     init                  Set up the metro CLI alias
     clean                 Run flutter clean and flutter pub get
+      --ios               Deep clean iOS (remove Pods, re-run pod install)
+      --android           Deep clean Android (run gradlew clean)
+      --all               Deep clean both iOS and Android
+    test                  Format and run Flutter tests
+      --no-format         Skip formatting before running tests
+      --filter=<pattern>  Filter tests by name
+      --coverage          Collect code coverage
+      --path=<dir>        Test directory path (default: test)
+    self-update           Update nylo to the latest version
 
   Options:
     -h, --help            Show usage information
@@ -83,6 +113,11 @@ void _printUsage() {
     nylo new MyAwesomeApp
     nylo init
     nylo clean
+    nylo clean --ios
+    nylo clean --all
+    nylo test
+    nylo test --filter "login" --coverage
+    nylo self-update
 
   Documentation: ${Constants.docsUrl}
 ''');

lib/nylo_installer.dart

@@ -3,6 +3,9 @@ library nylo_installer;
 
 export 'src/commands/metro_installer.dart';
 export 'src/commands/new_command.dart';
+export 'src/commands/self_update_command.dart';
+export 'src/commands/test_command.dart';
+export 'src/utils/version_checker.dart';
 export 'src/console/console.dart';
 export 'src/constants.dart';
 export 'src/utils/process_runner.dart';

lib/src/commands/clean_command.dart

@@ -1,21 +1,59 @@
 import 'dart:io';
-
+import 'package:args/args.dart';
 import '../console/console.dart';
 import '../utils/process_runner.dart';
 
 /// Handles the "nylo clean" command
 /// Runs flutter clean followed by flutter pub get
+/// Supports --ios, --android, and --all flags for platform-specific deep cleaning
 class CleanCommand {
   /// Execute the clean command
-  Future<void> run() async {
+  Future<void> run([List<String> arguments = const []]) async {
+    final parser = ArgParser()
+      ..addFlag('ios', negatable: false, help: 'Deep clean iOS')
+      ..addFlag('android', negatable: false, help: 'Deep clean Android')
+      ..addFlag('all', negatable: false, help: 'Deep clean iOS and Android');
+
+    final ArgResults results;
+    try {
+      results = parser.parse(arguments);
+    } on FormatException catch (e) {
+      NyloConsole.writeError(e.message);
+      exit(1);
+    }
+
+    bool cleanIos = results['ios'] as bool || results['all'] as bool;
+    bool cleanAndroid = results['android'] as bool || results['all'] as bool;
+
+    // Validate platform directories exist
+    if (cleanIos && !await Directory('ios').exists()) {
+      NyloConsole.writeWarning('ios/ directory not found. Skipping iOS clean.');
+      cleanIos = false;
+    }
+    if (cleanAndroid && !await Directory('android').exists()) {
+      NyloConsole.writeWarning(
+          'android/ directory not found. Skipping Android clean.');
+      cleanAndroid = false;
+    }
+
+    // Calculate steps dynamically
+    int totalSteps = 2; // flutter clean + flutter pub get
+    if (cleanIos) totalSteps += 2; // rm artifacts + pod install
+    if (cleanAndroid) totalSteps += 1; // gradlew clean
+    int currentStep = 0;
+    String stepLabel() {
+      currentStep++;
+      return '[$currentStep/$totalSteps]';
+    }
+
     NyloConsole.writeBanner();
     NyloConsole.write('');
     NyloConsole.writeInfo('Cleaning project...');
     NyloConsole.write('');
 
-    // Step 1: Run flutter clean
+    // Step: Run flutter clean
     final cleanSpinner = Spinner('');
-    cleanSpinner.start('[1/2] Running flutter clean...');
+    cleanSpinner.start('${stepLabel()} Running flutter clean...');
     final cleanResult = await ProcessRunner.run('flutter', ['clean']);
     cleanSpinner.stop('flutter clean complete');
 
@@ -25,9 +63,57 @@ class CleanCommand {
       exit(1);
     }
 
-    // Step 2: Run flutter pub get
+    // iOS deep clean
+    if (cleanIos) {
+      // Step: Remove iOS artifacts
+      final rmSpinner = Spinner('');
+      rmSpinner.start('${stepLabel()} Removing iOS build artifacts...');
+      await _removeIosArtifacts();
+      rmSpinner.stop('iOS artifacts removed (Pods, .symlinks, Podfile.lock)');
+
+      // Step: pod install --repo-update
+      final podSpinner = Spinner('');
+      podSpinner.start('${stepLabel()} Running pod install --repo-update...');
+      if (!Platform.isMacOS) {
+        podSpinner.stop('pod install skipped (not macOS)');
+        NyloConsole.writeWarning(
+            'pod install is only available on macOS. Skipping.');
+      } else {
+        final podResult = await ProcessRunner.run(
+          'pod',
+          ['install', '--repo-update'],
+          workingDirectory: 'ios',
+        );
+        podSpinner.stop('pod install complete');
+
+        if (podResult.exitCode != 0) {
+          NyloConsole.writeWarning('pod install completed with warnings');
+          NyloConsole.writeWarning(podResult.stderr);
+        }
+      }
+    }
+
+    // Android deep clean
+    if (cleanAndroid) {
+      final gradleSpinner = Spinner('');
+      gradleSpinner.start('${stepLabel()} Running gradlew clean...');
+      final gradlew = Platform.isWindows ? 'gradlew.bat' : './gradlew';
+      final gradleResult = await ProcessRunner.run(
+        gradlew,
+        ['clean'],
+        workingDirectory: 'android',
+      );
+      gradleSpinner.stop('gradlew clean complete');
+
+      if (gradleResult.exitCode != 0) {
+        NyloConsole.writeWarning('gradlew clean completed with warnings');
+        NyloConsole.writeWarning(gradleResult.stderr);
+      }
+    }
+
+    // Step: Run flutter pub get
     final pubGetSpinner = Spinner('');
-    pubGetSpinner.start('[2/2] Running flutter pub get...');
+    pubGetSpinner.start('${stepLabel()} Running flutter pub get...');
     final pubGetResult = await ProcessRunner.run('flutter', ['pub', 'get']);
     pubGetSpinner.stop('flutter pub get complete');
 
@@ -38,4 +124,26 @@ class CleanCommand {
     NyloConsole.write('');
     NyloConsole.writeSuccess('Project cleaned successfully!');
   }
+
+  /// Remove iOS build artifacts (Pods, .symlinks, Podfile.lock)
+  Future<void> _removeIosArtifacts() async {
+    final directories = [
+      Directory('ios/Pods'),
+      Directory('ios/.symlinks'),
+    ];
+    final files = [
+      File('ios/Podfile.lock'),
+    ];
+
+    for (final dir in directories) {
+      if (await dir.exists()) {
+        await dir.delete(recursive: true);
+      }
+    }
+    for (final file in files) {
+      if (await file.exists()) {
+        await file.delete();
+      }
+    }
+  }
 }

lib/src/commands/self_update_command.dart

@@ -0,0 +1,55 @@
+import 'dart:io';
+
+import '../console/console.dart';
+import '../constants.dart';
+import '../utils/process_runner.dart';
+import '../utils/version_checker.dart';
+
+/// Handles the "nylo self-update" command
+/// Updates the nylo_installer to the latest version from pub.dev
+class SelfUpdateCommand {
+  /// Execute the self-update command
+  Future<void> run() async {
+    NyloConsole.writeInfo('Checking for updates...');
+
+    final checker = VersionChecker();
+    final latestVersion = await checker.fetchLatestVersion();
+
+    if (latestVersion == null) {
+      NyloConsole.writeError(
+          'Could not check for updates. Please check your internet connection.');
+      exit(1);
+    }
+
+    if (latestVersion == Constants.version) {
+      NyloConsole.writeSuccess(
+          'You\'re already on the latest version (${Constants.version})');
+      return;
+    }
+
+    NyloConsole.write('');
+    NyloConsole.writeInfo(
+        'Updating nylo_installer ${Constants.version} → $latestVersion...');
+    NyloConsole.write('');
+
+    final spinner = Spinner('');
+    spinner.start('Installing update...');
+
+    final result = await ProcessRunner.run(
+      'dart',
+      ['pub', 'global', 'activate', Constants.packageName],
+    );
+
+    spinner.stop();
+
+    if (result.exitCode != 0) {
+      NyloConsole.writeError('Update failed.');
+      if (result.stderr.isNotEmpty) {
+        NyloConsole.writeError(result.stderr);
+      }
+      exit(1);
+    }
+
+    NyloConsole.writeSuccess('Updated nylo_installer to $latestVersion');
+  }
+}