[camera_android_camerax] Migrate check-readiness skill from bash to Dart

.ci/targets/analyze.yaml

@@ -14,7 +14,7 @@ tasks:
     script: .ci/scripts/tool_runner.sh
     # DO NOT change the custom-analysis argument here without changing the Dart repo.
     # See the comment in script/configs/custom_analysis.yaml for details.
-    args: ["analyze", "--custom-analysis=script/configs/custom_analysis.yaml"]
+    args: ["analyze", "--custom-analysis=script/configs/custom_analysis.yaml", "--analyze-skills-for=script/configs/skills_analysis.yaml"]
     # Re-run analysis with path-based dependencies to ensure that publishing
     # the changes won't break analysis of other packages in the respository
     # that depend on it.

packages/camera/camera_android_camerax/.agents/skills/check-readiness/SKILL.md

@@ -9,9 +9,9 @@ metadata:
 This skill verifies that the local environment is properly configured and clean before starting new work in the `camera_android_camerax` package.
 
 ## Instructions
-Run the bundled verification script ([scripts/check.sh](scripts/check.sh)) to perform the automated environment checks:
+Run the bundled verification script ([bin/check.dart](bin/check.dart)) to perform the automated environment checks:
 ```bash
-bash .agents/skills/check-readiness/scripts/check.sh
+dart run .agents/skills/check-readiness/bin/check.dart
 ```
 
 ### Handling the Results

packages/camera/camera_android_camerax/.agents/skills/check-readiness/bin/check.dart

@@ -0,0 +1,17 @@
+// Copyright 2013 The Flutter Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'dart:io';
+
+import 'package:check_readiness/check_readiness.dart';
+
+Future<void> main(List<String> args) async {
+  // Since this tool is executed via `dart run` from the package root,
+  // the current directory is the workspace root.
+  final String workspaceRoot = Directory.current.path;
+
+  final checker = ReadinessChecker();
+  final bool isReady = await checker.checkReadiness(workspaceRoot);
+  exitCode = isReady ? 0 : 1;
+}

packages/camera/camera_android_camerax/.agents/skills/check-readiness/lib/check_readiness.dart

@@ -0,0 +1,140 @@
+// Copyright 2013 The Flutter Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'dart:io';
+
+import 'package:file/file.dart';
+import 'package:file/local.dart';
+import 'package:path/path.dart' as p;
+import 'package:process/process.dart';
+
+/// Checks if the environment is ready for new work.
+class ReadinessChecker {
+  /// Creates a new ReadinessChecker.
+  ReadinessChecker({
+    FileSystem? fileSystem,
+    ProcessManager? processManager,
+    void Function(Object?)? log,
+  })  : _fileSystem = fileSystem ?? const LocalFileSystem(),
+        _processManager = processManager ?? const LocalProcessManager(),
+        _log = log ?? ((Object? msg) => stdout.writeln(msg));
+
+  final FileSystem _fileSystem;
+  final ProcessManager _processManager;
+  final void Function(Object?) _log;
+
+  /// Runs all readiness checks.
+  ///
+  /// Returns `true` if ready, `false` otherwise.
+  Future<bool> checkReadiness(String workspaceRoot) async {
+    _log('Checking if environment is ready for new work...');
+
+    if (!await _checkSymlinks(workspaceRoot)) {
+      return false;
+    }
+    if (!await _checkGitState(workspaceRoot)) {
+      return false;
+    }
+    if (!await _checkFlutterAndDart()) {
+      return false;
+    }
+    if (!await _checkDependencies(workspaceRoot)) {
+      return false;
+    }
+
+    _log('Environment is fully ready!');
+    return true;
+  }
+
+  Future<bool> _checkSymlinks(String workspaceRoot) async {
+    _log('1. Checking skill symlinks...');
+    final Directory agentsDir = _fileSystem.directory(p.join(workspaceRoot, '.agents', 'skills'));
+    if (!agentsDir.existsSync()) {
+      // If it doesn't exist, there are no broken symlinks.
+      _log('All symlinks resolve correctly.');
+      return true;
+    }
+
+    final brokenLinks = <String>[];
+    await for (final FileSystemEntity entity
+        in agentsDir.list(recursive: true, followLinks: false)) {
+      if (entity is Link) {
+        if (_fileSystem.typeSync(entity.path) == FileSystemEntityType.notFound) {
+          brokenLinks.add(entity.path);
+        }
+      }
+    }
+
+    if (brokenLinks.isNotEmpty) {
+      _log('Error: Found broken symlinks in .agents/skills:');
+      brokenLinks.forEach(_log);
+      return false;
+    }
+
+    _log('All symlinks resolve correctly.');
+    return true;
+  }
+
+  Future<bool> _checkGitState(String workspaceRoot) async {
+    _log('2. Checking git state...');
+    final ProcessResult result;
+    try {
+      result = await _processManager.run(
+        ['git', 'status', '--porcelain'],
+        workingDirectory: workspaceRoot,
+      );
+    } on ProcessException catch (e) {
+      _log('Error: Failed to run git status. Is git installed and on the PATH?');
+      _log(e.toString());
+      return false;
+    }
+    if (result.exitCode != 0) {
+      _log('Error: Failed to run git status.');
+      return false;
+    }
+    final String stdoutStr = (result.stdout as String).trim();
+    if (stdoutStr.isNotEmpty) {
+      _log(
+          'Error: Git working directory is not clean. Please commit or stash your changes before starting new work.');
+      return false;
+    }
+    _log('Git working directory is clean.');
+    return true;
+  }
+
+  Future<bool> _checkFlutterAndDart() async {
+    _log('3. Checking Flutter and Dart...');
+    if (!_canRunCommand('flutter')) {
+      _log("Error: 'flutter' is not on the PATH.");
+      return false;
+    }
+    if (!_canRunCommand('dart')) {
+      _log("Error: 'dart' is not on the PATH.");
+      return false;
+    }
+    _log('Flutter and Dart are on the PATH.');
+    return true;
+  }
+
+  bool _canRunCommand(String command) {
+    // A simple check using ProcessManager's canRun
+    // NOTE: ProcessManager.canRun exists if we use process package > certain version
+    // Let's implement a safe check
+    return _processManager.canRun(command);
+  }
+
+  Future<bool> _checkDependencies(String workspaceRoot) async {
+    _log('4. Checking dependencies in camera_android_camerax...');
+    final ProcessResult result = await _processManager.run(
+      ['flutter', 'pub', 'get'],
+      workingDirectory: workspaceRoot,
+    );
+    if (result.exitCode != 0) {
+      _log('Error: Failed to resolve dependencies.');
+      return false;
+    }
+    _log('Dependencies are resolved and ready.');
+    return true;
+  }
+}

packages/camera/camera_android_camerax/.agents/skills/check-readiness/pubspec.yaml

@@ -0,0 +1,16 @@
+name: check_readiness
+description: A tool to check if the repository is ready for new work, intended only for use in the check-readiness skill.
+version: 0.1.0
+publish_to: none
+
+environment:
+  sdk: ^3.0.0
+
+dev_dependencies:
+  build_runner: ^2.15.0
+  mockito: ^5.7.0
+  test: ^1.24.0
+dependencies:
+  file: ^7.0.1
+  path: ^1.9.1
+  process: ^5.0.5

packages/camera/camera_android_camerax/.agents/skills/check-readiness/test/check_test.dart

@@ -0,0 +1,144 @@
+// Copyright 2013 The Flutter Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'dart:async';
+import 'dart:convert';
+import 'dart:io';
+
+import 'package:check_readiness/check_readiness.dart';
+import 'package:file/memory.dart';
+import 'package:file/src/interface/directory.dart';
+import 'package:file/src/interface/link.dart';
+import 'package:path/path.dart' as p;
+import 'package:process/process.dart';
+import 'package:test/test.dart';
+
+class FakeProcessManager implements ProcessManager {
+  final Map<String, bool> canRunMock = {};
+  final Map<String, ProcessResult> runMock = {};
+  final List<List<String>> runInvocations = [];
+
+  @override
+  bool canRun(dynamic executable, {String? workingDirectory}) {
+    return canRunMock[executable as String] ?? true;
+  }
+
+  @override
+  Future<ProcessResult> run(
+    List<dynamic> command, {
+    String? workingDirectory,
+    Map<String, String>? environment,
+    bool includeParentEnvironment = true,
+    bool runInShell = false,
+    Encoding? stdoutEncoding = systemEncoding,
+    Encoding? stderrEncoding = systemEncoding,
+  }) async {
+    final List<String> cmdList = command.cast<String>();
+    runInvocations.add(cmdList);
+    final String key = cmdList.join(' ');
+    if (runMock.containsKey(key)) {
+      return runMock[key]!;
+    }
+    return ProcessResult(0, 0, '', '');
+  }
+
+  // The rest of the interface is unimplemented.
+  @override
+  dynamic noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+}
+
+void main() {
+  late MemoryFileSystem fileSystem;
+  late FakeProcessManager processManager;
+  late ReadinessChecker checker;
+  late String workspaceRoot;
+  final List<String> printLogs = [];
+
+  setUp(() {
+    fileSystem = MemoryFileSystem.test();
+    processManager = FakeProcessManager();
+    checker = ReadinessChecker(
+      fileSystem: fileSystem,
+      processManager: processManager,
+      log: (Object? message) => printLogs.add(message.toString()),
+    );
+    workspaceRoot = '/workspace';
+    printLogs.clear();
+  });
+
+  /// Runs the checker and captures prints
+  Future<bool> runChecker() async {
+    return checker.checkReadiness(workspaceRoot);
+  }
+
+  test('passes when everything is correct', () async {
+    // Setup empty skills dir (no broken symlinks)
+    fileSystem.directory(p.join(workspaceRoot, '.agents', 'skills')).createSync(recursive: true);
+
+    // Git returns clean
+    processManager.runMock['git status --porcelain'] = ProcessResult(0, 0, '', '');
+
+    final bool result = await runChecker();
+    expect(result, isTrue);
+    expect(printLogs, contains('Environment is fully ready!'));
+  });
+
+  test('fails when a broken symlink is present', () async {
+    final Directory skillsDir = fileSystem.directory(p.join(workspaceRoot, '.agents', 'skills'))
+      ..createSync(recursive: true);
+
+    // MemoryFileSystem supports links
+    final Link link = fileSystem.link(p.join(skillsDir.path, 'broken_link'));
+    link.createSync('non_existent_target');
+
+    final bool result = await runChecker();
+    expect(result, isFalse);
+    expect(
+        printLogs.any((line) => line.contains('Found broken symlinks in .agents/skills:')), isTrue);
+  });
+
+  test('fails when git is dirty', () async {
+    fileSystem.directory(p.join(workspaceRoot, '.agents', 'skills')).createSync(recursive: true);
+
+    processManager.runMock['git status --porcelain'] = ProcessResult(0, 0, ' M file.txt\n', '');
+
+    final bool result = await runChecker();
+    expect(result, isFalse);
+    expect(
+        printLogs,
+        contains(
+            'Error: Git working directory is not clean. Please commit or stash your changes before starting new work.'));
+  });
+
+  test('fails when flutter is missing', () async {
+    fileSystem.directory(p.join(workspaceRoot, '.agents', 'skills')).createSync(recursive: true);
+
+    processManager.canRunMock['flutter'] = false;
+
+    final bool result = await runChecker();
+    expect(result, isFalse);
+    expect(printLogs, contains("Error: 'flutter' is not on the PATH."));
+  });
+
+  test('fails when dart is missing', () async {
+    fileSystem.directory(p.join(workspaceRoot, '.agents', 'skills')).createSync(recursive: true);
+
+    processManager.canRunMock['dart'] = false;
+
+    final bool result = await runChecker();
+    expect(result, isFalse);
+    expect(printLogs, contains("Error: 'dart' is not on the PATH."));
+  });
+
+  test('fails when flutter pub get fails', () async {
+    fileSystem.directory(p.join(workspaceRoot, '.agents', 'skills')).createSync(recursive: true);
+
+    processManager.runMock['git status --porcelain'] = ProcessResult(0, 0, '', '');
+    processManager.runMock['flutter pub get'] = ProcessResult(0, 1, '', 'Error');
+
+    final bool result = await runChecker();
+    expect(result, isFalse);
+    expect(printLogs, contains('Error: Failed to resolve dependencies.'));
+  });
+}

script/configs/skills_analysis.yaml

@@ -0,0 +1 @@
+- camera_android_camerax