@bdayadev/flutter-ultra-mcp 1.11.7 → 1.13.0

package/skills/generate-test-mocks/SKILL.md

@@ -0,0 +1,177 @@
+---
+name: generate-test-mocks
+description: Define and generate mock objects for external dependencies using `package:mockito` and `build_runner`. Use when unit testing classes that depend on complex external services like APIs or databases.
+  last_modified: Fri, 24 Apr 2026 15:13:58 GMT
+---
+
+# Testing and Mocking Dart Applications
+
+## Contents
+
+- [Structuring Code for Testability](#structuring-code-for-testability)
+- [Managing Dependencies](#managing-dependencies)
+- [Generating Mocks](#generating-mocks)
+- [Implementing Unit Tests](#implementing-unit-tests)
+- [Workflow: Creating and Running Mocked Tests](#workflow-creating-and-running-mocked-tests)
+- [Examples](#examples)
+
+## Structuring Code for Testability
+
+Design Dart classes to support dependency injection. Isolate complex external dependencies (like API clients or databases) so they can be replaced with mock objects during testing.
+
+- Inject external services (e.g., `http.Client`) through class constructors.
+- Represent URLs strictly as `Uri` objects using `Uri.parse(string)`.
+- Utilize Dart's object-oriented features (classes, mixins) to define clear interfaces for external interactions.
+
+## Managing Dependencies
+
+Configure the `pubspec.yaml` file with the necessary testing and code generation packages.
+
+- Add runtime dependencies (e.g., `package:http`) using `dart pub add http`.
+- Add testing dependencies using `dart pub add dev:test dev:mockito dev:build_runner`.
+- Import HTTP libraries with a prefix to avoid namespace collisions: `import 'package:http/http.dart' as http;`.
+
+## Generating Mocks
+
+Use `package:mockito` and `build_runner` to automatically generate mock classes for fixed scenarios and behavior verification.
+
+- Always use the `@GenerateNiceMocks` annotation (preferable to `@GenerateMocks` to avoid missing stub exceptions).
+- Place the annotation in the test file, passing a list of `MockSpec<Type>()` objects.
+- Import the generated file using the `.mocks.dart` extension.
+- Execute `build_runner` to generate the mock files: `dart run build_runner build`.
+
+## Implementing Unit Tests
+
+Isolate the system under test using the generated mock objects. Use `package:test` to structure the test suite.
+
+- **Stubbing:** Configure mock behavior before interacting with the system under test.
+  - Use `when(mock.method()).thenReturn(value)` for synchronous methods.
+  - **CRITICAL:** Always use `thenAnswer((_) async => value)` for methods returning a `Future` or `Stream`. Never use `thenReturn` for asynchronous returns.
+- **Verification:** Assert that the system under test interacted with the mock object correctly.
+  - Use `verify(mock.method()).called(1)` to check exact invocation counts.
+  - Use argument matchers like `any`, `anyNamed`, or `captureAny` for flexible verification.
+
+## Workflow: Creating and Running Mocked Tests
+
+Use the following checklist to implement and verify mocked unit tests.
+
+### Task Progress
+
+- [ ] 1. Identify the external dependency to mock (e.g., `http.Client`).
+- [ ] 2. Inject the dependency into the target class constructor.
+- [ ] 3. Create a test file (e.g., `target_test.dart`) and add `@GenerateNiceMocks([MockSpec<Dependency>()])`.
+- [ ] 4. Add the `part` or `import` directive for the generated `.mocks.dart` file.
+- [ ] 5. Run `dart run build_runner build` to generate the mock classes.
+- [ ] 6. Write the test cases using `group()` and `test()`.
+- [ ] 7. Stub required behaviors using `when()`.
+- [ ] 8. Execute the target method.
+- [ ] 9. Verify interactions using `verify()` and assert outcomes using `expect()`.
+- [ ] 10. Run the test suite using `dart test`.
+
+### Feedback Loop: Test Failures
+
+If tests fail or `build_runner` encounters errors:
+
+1. **Run validator:** Execute `dart test` or `dart run build_runner build`.
+2. **Review errors:** Check for missing stubs, mismatched argument matchers, or syntax errors in the generated files.
+3. **Fix:**
+   - If a mock method throws an unexpected null error, ensure you used `@GenerateNiceMocks`.
+   - If an async stub throws an `ArgumentError`, change `thenReturn` to `thenAnswer`.
+   - If `build_runner` fails, ensure the `.mocks.dart` import matches the file name exactly.
+4. Repeat until all tests pass.
+
+## Examples
+
+### High-Fidelity Mocking and Testing Example
+
+**1. System Under Test (`lib/api_service.dart`)**
+
+```dart
+import 'dart:convert';
+import 'package:http/http.dart' as http;
+
+class ApiService {
+  final http.Client client;
+
+  ApiService(this.client);
+
+  Future<String> fetchData(String urlString) async {
+    final uri = Uri.parse(urlString);
+    final response = await client.get(uri);
+
+    if (response.statusCode == 200) {
+      return jsonDecode(response.body)['data'];
+    } else {
+      throw Exception('Failed to load data');
+    }
+  }
+}
+```
+
+**2. Test Implementation (`test/api_service_test.dart`)**
+
+```dart
+import 'package:test/test.dart';
+import 'package:mockito/annotations.dart';
+import 'package:mockito/mockito.dart';
+import 'package:http/http.dart' as http;
+import 'package:my_app/api_service.dart';
+
+// Generate the mock class for http.Client
+@GenerateNiceMocks([MockSpec<http.Client>()])
+import 'api_service_test.mocks.dart';
+
+void main() {
+  group('ApiService', () {
+    late ApiService apiService;
+    late MockClient mockHttpClient;
+
+    setUp(() {
+      mockHttpClient = MockClient();
+      apiService = ApiService(mockHttpClient);
+    });
+
+    test('returns data if the http call completes successfully', () async {
+      // Arrange: Stub the async HTTP GET request using thenAnswer
+      when(mockHttpClient.get(any)).thenAnswer(
+        (_) async => http.Response('{"data": "Success"}', 200),
+      );
+
+      // Act
+      final result = await apiService.fetchData('https://api.example.com/data');
+
+      // Assert
+      expect(result, 'Success');
+
+      // Verify the mock was called with the correct Uri
+      verify(mockHttpClient.get(Uri.parse('https://api.example.com/data'))).called(1);
+    });
+
+    test('throws an exception if the http call completes with an error', () {
+      // Arrange
+      when(mockHttpClient.get(any)).thenAnswer(
+        (_) async => http.Response('Not Found', 404),
+      );
+
+      // Act & Assert
+      expect(
+        apiService.fetchData('https://api.example.com/data'),
+        throwsException,
+      );
+    });
+  });
+}
+```
+
+## Flutter Ultra Integration
+
+Run build_runner to generate mock classes:
+
+- `mcp__plugin_flutter_flutter-ultra-build__start_build_runner_build` — Run build_runner to generate \*.mocks.dart files
+- `mcp__plugin_flutter_flutter-ultra-build__poll_build_runner_job` — Monitor generation progress
+- `mcp__plugin_flutter_flutter-ultra-build__get_build_runner_result` — Check for generation errors
+
+---
+
+> **Attribution:** This skill is vendored from [dart-lang/skills](https://github.com/dart-lang/skills) (BSD-3-Clause).
+> Synced by `scripts/sync-upstream-skills.mjs`. Do not edit manually — changes will be overwritten on next sync.

package/skills/implement-json-serialization/SKILL.md

@@ -0,0 +1,168 @@
+---
+name: implement-json-serialization
+description: Create model classes with `fromJson` and `toJson` methods using `dart:convert`. Use when manually mapping JSON keys to class properties for simple data structures.
+  last_modified: Tue, 21 Apr 2026 21:44:50 GMT
+---
+
+# Serializing JSON Manually in Flutter
+
+## Contents
+
+- [Core Guidelines](#core-guidelines)
+- [Workflow: Implementing a Serializable Model](#workflow-implementing-a-serializable-model)
+- [Workflow: Fetching and Parsing JSON](#workflow-fetching-and-parsing-json)
+- [Examples](#examples)
+
+## Core Guidelines
+
+- **Import `dart:convert`**: Utilize Flutter's built-in `dart:convert` library for manual JSON encoding (`jsonEncode`) and decoding (`jsonDecode`).
+- **Enforce Type Safety**: Always cast the `dynamic` result of `jsonDecode()` to the expected type, typically `Map<String, dynamic>` for objects or `List<dynamic>` for arrays.
+- **Encapsulate Serialization Logic**: Define plain model classes containing properties corresponding to the JSON structure. Implement a `fromJson` factory constructor and a `toJson` method within the model.
+- **Handle Background Parsing**: If parsing large JSON documents (execution time > 16ms), offload the parsing logic to a separate isolate using Flutter's `compute()` function to prevent UI jank.
+- **Throw Exceptions on Failure**: When handling HTTP responses, throw an exception if the status code is not successful (e.g., not 200 OK or 201 Created). Do not return `null`.
+
+## Workflow: Implementing a Serializable Model
+
+Use this checklist to implement manual JSON serialization for a data model.
+
+**Task Progress:**
+
+- [ ] Define the plain model class with `final` properties.
+- [ ] Implement the `factory Model.fromJson(Map<String, dynamic> json)` constructor.
+- [ ] Implement the `Map<String, dynamic> toJson()` method.
+- [ ] Write unit tests for both serialization methods.
+- [ ] Run validator -> review type mismatch errors -> fix casting logic.
+
+1. **Define the Model**: Create a class with properties matching the JSON keys.
+2. **Implement `fromJson`**: Extract values from the `Map` and cast them to the appropriate Dart types. Use pattern matching or explicit casting.
+3. **Implement `toJson`**: Return a `Map<String, dynamic>` mapping the class properties back to their JSON string keys.
+4. **Validate**: Execute unit tests to ensure type safety, autocompletion, and compile-time exception handling function correctly.
+
+## Workflow: Fetching and Parsing JSON
+
+Use this conditional workflow when retrieving and parsing JSON from a network request.
+
+**Task Progress:**
+
+- [ ] Execute the HTTP request.
+- [ ] Validate the response status code.
+- [ ] Determine parsing strategy (Synchronous vs. Isolate).
+- [ ] Decode and map the JSON to the model.
+
+1. **Execute Request**: Use the `http` package to perform the network call.
+2. **Validate Response**:
+   - If `response.statusCode == 200` (or 201 for POST), proceed to parsing.
+   - If the status code indicates failure, throw an `Exception`.
+3. **Determine Parsing Strategy**:
+   - If parsing a **small payload** (e.g., a single object), parse synchronously on the main thread.
+   - If parsing a **large payload** (e.g., an array of thousands of objects), use `compute(parseFunction, response.body)` to parse in a background isolate.
+4. **Decode and Map**: Pass the decoded JSON to your model's `fromJson` constructor.
+
+## Examples
+
+### High-Fidelity Model Implementation
+
+```dart
+import 'dart:convert';
+
+class User {
+  final int id;
+  final String name;
+  final String email;
+
+  const User({
+    required this.id,
+    required this.name,
+    required this.email,
+  });
+
+  // Factory constructor for deserialization
+  factory User.fromJson(Map<String, dynamic> json) {
+    return switch (json) {
+      {
+        'id': int id,
+        'name': String name,
+        'email': String email,
+      } =>
+        User(
+          id: id,
+          name: name,
+          email: email,
+        ),
+      _ => throw const FormatException('Failed to load User.'),
+    };
+  }
+
+  // Method for serialization
+  Map<String, dynamic> toJson() {
+    return {
+      'id': id,
+      'name': name,
+      'email': email,
+    };
+  }
+}
+```
+
+### Synchronous Parsing (Small Payload)
+
+```dart
+import 'dart:convert';
+import 'package:http/http.dart' as http;
+
+Future<User> fetchUser(http.Client client, int userId) async {
+  final response = await client.get(
+    Uri.parse('https://api.example.com/users/$userId'),
+    headers: {'Accept': 'application/json'},
+  );
+
+  if (response.statusCode == 200) {
+    // Decode returns dynamic, cast to Map<String, dynamic>
+    final Map<String, dynamic> jsonMap = jsonDecode(response.body) as Map<String, dynamic>;
+    return User.fromJson(jsonMap);
+  } else {
+    throw Exception('Failed to load user');
+  }
+}
+```
+
+### Background Parsing (Large Payload)
+
+```dart
+import 'dart:convert';
+import 'package:flutter/foundation.dart';
+import 'package:http/http.dart' as http;
+
+// Top-level function required for compute()
+List<User> parseUsers(String responseBody) {
+  final parsed = (jsonDecode(responseBody) as List<dynamic>).cast<Map<String, dynamic>>();
+  return parsed.map<User>((json) => User.fromJson(json)).toList();
+}
+
+Future<List<User>> fetchUsers(http.Client client) async {
+  final response = await client.get(
+    Uri.parse('https://api.example.com/users'),
+    headers: {'Accept': 'application/json'},
+  );
+
+  if (response.statusCode == 200) {
+    // Offload expensive parsing to a background isolate
+    return compute(parseUsers, response.body);
+  } else {
+    throw Exception('Failed to load users');
+  }
+}
+```
+
+## Flutter Ultra Integration
+
+If using code generation (json_serializable), run the build runner:
+
+- `mcp__plugin_flutter_flutter-ultra-build__start_build_runner_build` — Run build_runner to generate serialization code
+- `mcp__plugin_flutter_flutter-ultra-build__poll_build_runner_job` — Monitor code generation progress
+- `mcp__plugin_flutter_flutter-ultra-build__analyze` — Verify generated code has no analysis errors
+
+---
+
+> **Attribution:** This skill is vendored from [flutter/skills](https://github.com/flutter/skills) (BSD-3-Clause).
+> Synced by `scripts/sync-upstream-skills.mjs`. Do not edit manually — changes will be overwritten on next sync.

package/skills/migrate-to-checks-package/SKILL.md

@@ -0,0 +1,156 @@
+---
+name: migrate-to-checks-package
+description: Replace the usage of `expect` and similar functions from `package:matcher` to `package:checks` equivalents.
+  last_modified: Fri, 24 Apr 2026 15:15:22 GMT
+---
+
+# Migrating Dart Tests to Package Checks
+
+## Contents
+
+- [Dependency Management](#dependency-management)
+- [Syntax Migration Guidelines](#syntax-migration-guidelines)
+- [Utilizing Dart MCP Tools](#utilizing-dart-mcp-tools)
+- [Migration Workflow](#migration-workflow)
+- [Examples](#examples)
+
+## Dependency Management
+
+Manage dependencies using the Dart Tooling MCP Server `pub` tool or standard CLI commands.
+
+- Add `package:checks` as a `dev_dependency` using `dart pub add dev:checks`.
+- Remove `package:matcher` if it is explicitly listed in the `pubspec.yaml` (note: it is often transitively included by `package:test`, which is fine).
+- Import `package:checks/checks.dart` in all test files undergoing migration.
+
+## Syntax Migration Guidelines
+
+Transition test assertions from the `package:matcher` syntax to the literate API provided by `package:checks`.
+
+- **Basic Equality:** Replace `expect(actual, equals(expected))` or `expect(actual, expected)` with `check(actual).equals(expected)`.
+- **Type Checking:** Replace `expect(actual, isA<Type>())` with `check(actual).isA<Type>()`.
+- **Property Extraction:** Replace `expect(actual.property, expected)` with `check(actual).has((a) => a.property, 'property name').equals(expected)`.
+- **Cascades for Multiple Checks:** Use Dart's cascade operator (`..`) to chain multiple expectations on a single subject.
+- **Asynchronous Expectations:**
+  - If checking a `Future`, `await` the `check` call: `await check(someFuture).completes((r) => r.equals(expected));`.
+  - If checking a `Stream`, wrap it in a `StreamQueue` for multiple checks, or use `.withQueue` for single/broadcast checks.
+
+## Utilizing Dart MCP Tools
+
+Leverage the Dart MCP Server tools to automate and validate the migration process.
+
+- Use `pub` to run `dart pub get` or `dart pub add`.
+- Use `analyze_files` to run static analysis on the project or specific paths.
+- Use `run_tests` to execute Dart or Flutter tests with an agent-centric UX. ALWAYS use this instead of shell commands like `dart test`.
+- Use `dart_fix` to apply automated fixes if applicable.
+
+## Migration Workflow
+
+Copy and use the following checklist to track progress when migrating a test suite:
+
+- [ ] **Task Progress**
+  - [ ] Add `package:checks` as a dev dependency.
+  - [ ] Identify all test files using `package:matcher` (`expect` calls).
+  - [ ] Import `package:checks/checks.dart` in target test files.
+  - [ ] Rewrite all `expect(...)` statements to `check(...)` statements.
+  - [ ] Run static analyzer (`analyze_files`).
+  - [ ] Run tests (`run_tests`).
+
+### Feedback Loop: Static Analysis
+
+1. Run the `analyze_files` tool on the modified test directories.
+2. Review any static analysis warnings or errors (e.g., missing imports, incorrect generic types on `isA`, unawaited futures).
+3. Fix the warnings.
+4. Repeat until the analyzer returns zero issues.
+
+### Feedback Loop: Test Validation
+
+1. Run the `run_tests` tool.
+2. If tests fail, review the failure output. `package:checks` provides detailed context (e.g., `Which: has length of <2>`).
+3. Adjust the `check()` expectations or the underlying code to resolve the failure.
+4. Repeat until all tests pass.
+
+## Examples
+
+### Basic Assertions
+
+**Input (`matcher`):**
+
+```dart
+expect(someList.length, 1);
+expect(someString, startsWith('a'));
+expect(someObject, isA<Map>());
+```
+
+**Output (`checks`):**
+
+```dart
+check(someList).length.equals(1);
+check(someString).startsWith('a');
+check(someObject).isA<Map>();
+```
+
+### Composed Expectations
+
+**Input (`matcher`):**
+
+```dart
+expect('foo,bar,baz', allOf([
+  contains('foo'),
+  isNot(startsWith('bar')),
+  endsWith('baz')
+]));
+```
+
+**Output (`checks`):**
+
+```dart
+check('foo,bar,baz')
+  ..contains('foo')
+  ..not((s) => s.startsWith('bar'))
+  ..endsWith('baz');
+```
+
+### Asynchronous Futures
+
+**Input (`matcher`):**
+
+```dart
+expect(Future.value(10), completion(equals(10)));
+expect(Future.error('oh no'), throwsA(equals('oh no')));
+```
+
+**Output (`checks`):**
+
+```dart
+await check(Future.value(10)).completes((it) => it.equals(10));
+await check(Future.error('oh no')).throws<String>().equals('oh no');
+```
+
+### Asynchronous Streams
+
+**Input (`matcher`):**
+
+```dart
+var stdout = StreamQueue(Stream.fromIterable(['Ready', 'Go']));
+await expectLater(stdout, emitsThrough('Ready'));
+```
+
+**Output (`checks`):**
+
+```dart
+var stdout = StreamQueue(Stream.fromIterable(['Ready', 'Go']));
+await check(stdout).emitsThrough((it) => it.equals('Ready'));
+```
+
+## Flutter Ultra Integration
+
+Validate the migration with static analysis and tests:
+
+- `mcp__plugin_flutter_flutter-ultra-build__analyze` — Check for type errors after migration
+- `mcp__plugin_flutter_flutter-ultra-build__fix` — Apply automated fixes for simple migrations
+- `mcp__plugin_flutter_flutter-ultra-build__start_run_unit_tests` — Run tests to verify migration didn't break assertions
+
+---
+
+> **Attribution:** This skill is vendored from [dart-lang/skills](https://github.com/dart-lang/skills) (BSD-3-Clause).
+> Synced by `scripts/sync-upstream-skills.mjs`. Do not edit manually — changes will be overwritten on next sync.

package/skills/resolve-package-conflicts/SKILL.md

@@ -0,0 +1,140 @@
+---
+name: resolve-package-conflicts
+description: Workflow for fixing package version conflicts. Use this when `pub get` fails due to incompatible package versions.
+  last_modified: Fri, 24 Apr 2026 15:11:14 GMT
+---
+
+# Managing Dart Dependencies
+
+## Contents
+
+- [Core Concepts](#core-concepts)
+- [Version Constraints](#version-constraints)
+- [Workflow: Auditing Dependencies](#workflow-auditing-dependencies)
+- [Workflow: Upgrading Dependencies](#workflow-upgrading-dependencies)
+- [Workflow: Resolving Version Conflicts](#workflow-resolving-version-conflicts)
+- [Examples](#examples)
+
+## Core Concepts
+
+Dart enforces a strict single-version rule for dependencies: a project and all its transitive dependencies must resolve to a single, shared version of any given package. This prevents runtime type mismatches but introduces the risk of "version lock."
+
+To mitigate version lock, Dart relies on version constraints rather than pinned versions in the `pubspec.yaml`. The `pubspec.lock` file maintains the exact resolved versions for reproducible builds.
+
+Understand the output columns of `dart pub outdated`:
+
+- **Current:** The version currently recorded in `pubspec.lock`.
+- **Upgradable:** The latest version allowed by the constraints in `pubspec.yaml`. `dart pub upgrade` resolves to this.
+- **Resolvable:** The absolute latest version that can be resolved when factoring in all other dependencies in the project.
+- **Latest:** The latest published version of the package (excluding prereleases).
+
+## Version Constraints
+
+- **Use Caret Syntax:** Always use caret syntax (e.g., `^1.2.3`) for dependencies in `pubspec.yaml`. This allows `pub` to select newer, non-breaking versions (up to, but not including, the next major version) during resolution.
+- **Tighten Dev Dependencies:** Set the lower bound of `dev_dependencies` to the exact version currently used. This reduces resolution complexity and prevents older, incompatible dev tools from being selected.
+- **Enforce Lockfiles in CI:** Use `dart pub get --enforce-lockfile` in CI/CD pipelines to ensure the exact versions tested locally are used in production.
+
+## Workflow: Auditing Dependencies
+
+Run this workflow periodically to identify stale packages that may impact stability or performance.
+
+**Task Progress:**
+
+- [ ] Run `dart pub outdated`.
+- [ ] Review the **Upgradable** column to identify packages that can be updated without modifying `pubspec.yaml`.
+- [ ] Review the **Resolvable** column to identify packages that require constraint modifications in `pubspec.yaml` to update.
+- [ ] Identify any packages marked as retracted or discontinued.
+
+## Workflow: Upgrading Dependencies
+
+Use conditional logic based on the audit results to upgrade dependencies.
+
+**Task Progress:**
+
+- [ ] **If updating to "Upgradable" versions:**
+  - [ ] Run `dart pub upgrade`.
+  - [ ] Run `dart pub upgrade --tighten` to automatically update the lower bounds in `pubspec.yaml` to match the newly resolved versions.
+- [ ] **If updating to "Resolvable" versions (Major updates):**
+  - [ ] Manually edit `pubspec.yaml` to bump the version constraint to match the "Resolvable" column (e.g., change `^0.11.0` to `^0.12.1`).
+  - [ ] Run `dart pub upgrade` to resolve the new constraints and update `pubspec.lock`.
+- [ ] **Feedback Loop:**
+  - [ ] Run `dart analyze` -> review errors -> fix breaking API changes.
+  - [ ] Run `dart test` -> review failures -> fix regressions.
+
+## Workflow: Resolving Version Conflicts
+
+When `pub` cannot find a set of concrete versions that satisfy all constraints, or when dealing with a retracted package version, manipulate the lockfile surgically.
+
+**NEVER** delete the entire `pubspec.lock` file and run `dart pub get`. This causes uncontrolled upgrades across the entire dependency graph.
+
+**Task Progress:**
+
+- [ ] Open `pubspec.lock`.
+- [ ] Locate the specific YAML block for the conflicting or retracted package.
+- [ ] Delete ONLY that package's entry from the lockfile.
+- [ ] Run `dart pub get` to fetch the newest compatible, non-retracted version for that specific package.
+- [ ] **Feedback Loop:**
+  - [ ] Run `dart pub deps` -> verify the dependency graph resolves correctly.
+  - [ ] If resolution fails, identify the transitive dependency causing the lock, update its constraint in `pubspec.yaml`, and retry.
+
+## Examples
+
+### Tightening Constraints
+
+When `dart pub outdated` shows a package is resolvable to a higher minor/patch version, use the `--tighten` flag to update the `pubspec.yaml` automatically.
+
+**Input (`pubspec.yaml`):**
+
+```yaml
+dependencies:
+  http: ^0.13.0
+```
+
+**Command:**
+
+```bash
+dart pub upgrade --tighten http
+```
+
+**Output (`pubspec.yaml`):**
+
+```yaml
+dependencies:
+  http: ^0.13.5
+```
+
+### Surgical Lockfile Removal
+
+If `package_a` is retracted or locked in a conflict, remove only its block from `pubspec.lock`.
+
+**Before (`pubspec.lock`):**
+
+```yaml
+packages:
+  package_a:
+    dependency: 'direct main'
+    description:
+      name: package_a
+      url: 'https://pub.dev'
+    source: hosted
+    version: '1.0.0' # Retracted version
+  package_b:
+    dependency: 'direct main'
+    # ...
+```
+
+**Action:** Delete the `package_a` block entirely. Leave `package_b` untouched. Run `dart pub get`.
+
+## Flutter Ultra Integration
+
+Investigate and resolve dependency conflicts:
+
+- `mcp__plugin_flutter_flutter-ultra-build__pub_get` — Run pub get to see the current resolution state
+- `mcp__plugin_flutter_flutter-ultra-build__pub_deps` — View the full dependency tree
+- `mcp__plugin_flutter_flutter-ultra-build__pub_outdated` — Check which packages are outdated
+- `mcp__plugin_flutter_flutter-ultra-build__pub_upgrade` — Attempt upgrade to resolve conflicts
+
+---
+
+> **Attribution:** This skill is vendored from [dart-lang/skills](https://github.com/dart-lang/skills) (BSD-3-Clause).
+> Synced by `scripts/sync-upstream-skills.mjs`. Do not edit manually — changes will be overwritten on next sync.