[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M75Q3AMXREFDH4VRPGHD7RYS":3,"skill-same:01M75Q3AMXREFDH4VRPGHD7RYS":48},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":18,"publishedAt":19,"linkOnly":20,"markdownContent":21,"markdownBody":22,"frontMatter":23,"refName":27,"commitSha":28,"skillDirectory":29,"forksCount":14,"repositoryHtmlUrl":30,"repositoryHomepageUrl":6,"ownerHtmlUrl":31,"ownerBlogUrl":32,"ownerDescription":6,"updatedAt":33,"install":34,"resources":47},"01M75Q3AMXREFDH4VRPGHD7RYS","dart-migrate-to-checks-package",null,"Replace the usage of `expect` and similar functions from `package:matcher`\nto `package:checks` equivalents.","mictlanix\u002Fmbe-ui","mictlanix","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F703184?v=4","01M75Q1XD9477GXRKPM6JVVC11","Mictlanix","01M75Q1XDXKYX3VS9T3CS2XEFR",0,"MIT","https:\u002F\u002Fgithub.com\u002Fmictlanix\u002Fmbe-ui\u002Fblob\u002Fmain\u002F.claude\u002Fskills\u002Fdart-migrate-to-checks-package\u002FSKILL.md",[],[],"2026-11-12 13:55:43",false,"---\nname: dart-migrate-to-checks-package\ndescription: |-\n  Replace the usage of `expect` and similar functions from `package:matcher`\n  to `package:checks` equivalents.\nmetadata:\n  model: models\u002Fgemini-3.1-pro-preview\n  last_modified: Tue, 09 Jun 2026 19:30:00 GMT\n---\n# Migrating Dart Tests to Package Checks\n\nUse this skill when you need to migrate a Dart test suite from the legacy\n`package:matcher` (which is exported by default from `package:test\u002Ftest.dart`)\nto the modern, type-safe, and literate `package:checks` assertion library.\n\n## Contents\n- [When to Use This Skill](#when-to-use-this-skill)\n- [How to Use This Skill (The Workflow)](#how-to-use-this-skill-the-workflow)\n- [Key Syntax Differences and Pitfalls](#key-syntax-differences-and-pitfalls)\n- [Matcher-to-Checks Mapping Table](#matcher-to-checks-mapping-table)\n- [Matchers with No Direct Replacements](#matchers-with-no-direct-replacements)\n- [Strategies for Discovery](#strategies-for-discovery)\n- [Examples](#examples)\n\n---\n\n## When to Use This Skill\n- When asked to \"migrate tests to checks\", \"use package:checks\", or\n  \"modernize test assertions\".\n- When updating legacy test suites where static type safety, better\n  autocomplete in IDEs, and highly detailed failure diagnostics are desired.\n\n---\n\n## How to Use This Skill (The Workflow)\n\nFollow this structured workflow to safely and systematically migrate a test suite:\n\n### 1. Dependency Setup\n- Add `package:checks` as a `dev_dependency` in `pubspec.yaml`:\n  ```bash\n  dart pub add dev:checks\n  ```\n- Remove `package:matcher` if it is explicitly listed under `dev_dependencies`\n  (it is typically transitively included by `package:test`, which is fine).\n\n### 2. Identify and Plan Target Files\n- Use the grep patterns in [Strategies for Discovery](#strategies-for-discovery)\n  to locate all test files containing legacy `expect` or `expectLater` calls.\n- Decide whether to migrate files fully or incrementally.\n\n### 3. Migrating a File (Incremental or Full)\nFor any target test file:\n1. **Update Imports**:\n   - Replace the generic `import 'package:test\u002Ftest.dart';` with:\n     ```dart\n     import 'package:test\u002Fscaffolding.dart';\n     import 'package:checks\u002Fchecks.dart';\n     ```\n   - **For Incremental Migration**: If you only want to migrate some test cases\n     in the file, or want to migrate one step at a time, add:\n     ```dart\n     import 'package:test\u002Fexpect.dart'; \u002F\u002F Temporarily allows legacy expect()\n     ```\n2. **Translate Assertions**: Rewrite legacy `expect` and `expectLater` calls\n   to `check` syntax following the [Key Syntax Differences and\n   Pitfalls](#key-syntax-differences-and-pitfalls) and the\n   [Matcher-to-Checks Mapping Table](#matcher-to-checks-mapping-table).\n3. **Verify via Compiler**: If migrating fully, remove the `import\n   'package:test\u002Fexpect.dart';` line. Any remaining un-migrated `expect`\n   calls will immediately surface as compiler errors, making them easy to\n   find and fix.\n\n### 4. Verification and Feedback Loops\n- **Static Analysis**: Run static analysis on the target package:\n  ```bash\n  dart analyze\n  ```\n  Pay close attention to generic type parameters on `.isA\u003CType>()` and\n  ensure asynchronous expectations are properly awaited (check for\n  `unawaited_futures` warnings).\n- **Run Tests**: Execute the tests to verify both behavior and correct\n  assertion runtime logic:\n  ```bash\n  dart test\n  ```\n  If a test fails, review the extremely detailed failure output of\n  `package:checks` to diagnose if the test is genuinely failing or if the\n  expectation was translated incorrectly.\n\n---\n\n## Key Syntax Differences and Pitfalls\n\n> [!IMPORTANT]\n> A line-for-line translation can sometimes introduce subtle bugs or false\n> passes. Always review these key differences carefully:\n\n### 1. Collection Equality Pitfall (`equals` vs `deepEquals`)\n- **Legacy Matcher**: `expect(actual, expected)` or `expect(actual,\n  equals(expected))` performed a **deep equality check** if the arguments\n  were collections (Lists, Maps, Sets).\n- **Package Checks**: `.equals(expected)` corresponds strictly to\n  `operator ==`. Since Dart collections do not override `operator ==` for\n  element-wise comparison, using `.equals` on a collection will check for\n  *identity* and almost certainly fail at runtime.\n- **Remediation**: You **must** replace collection equality assertions with\n  `.deepEquals(expected)`.\n  ```dart\n  \u002F\u002F BEFORE (Matcher)\n  expect(myList, [1, 2, 3]);\n\n  \u002F\u002F AFTER (Checks)\n  check(myList).deepEquals([1, 2, 3]);\n  ```\n\n### 2. The `reason` Parameter is now `because`\n- **Legacy Matcher**: The explanation was passed as a trailing named\n  argument `reason` to `expect`:\n  ```dart\n  expect(actual, expectation, reason: 'Explanation');\n  ```\n- **Package Checks**: The explanation is passed as the named argument\n  `because` to the `check` function *before* the actual subject:\n  ```dart\n  check(because: 'Explanation', actual).expectation();\n  ```\n\n### 3. Regular Expression Matching (`matches` vs `matchesPattern`)\n- **Legacy Matcher**: The `matches(pattern)` matcher automatically converted\n  a `String` argument into a `RegExp` (e.g., `matches(r'\\d')` matched `'1'`).\n- **Package Checks**: `.matchesPattern(pattern)` treats a `String` argument\n  as a literal string pattern.\n- **Remediation**: To match using a regular expression, you must explicitly\n  pass a `RegExp` object:\n  ```dart\n  \u002F\u002F BEFORE (Matcher)\n  expect(someString, matches(r'\\d+'));\n\n  \u002F\u002F AFTER (Checks)\n  check(someString).matchesPattern(RegExp(r'\\d+'));\n  ```\n\n### 4. Property Extraction (`TypeMatcher.having` vs `.has`)\n- **Legacy Matcher**: Chained field\u002Fproperty expectations used\n  `TypeMatcher.having(feature, description, matcher)`:\n  ```dart\n  expect(actual, isA\u003CPerson>().having((p) => p.name, 'name', startsWith('A')));\n  ```\n- **Package Checks**: The `.has(feature, description)` extension is\n  available on all `Subject`s, takes one fewer argument, and returns a new\n  `Subject` representing that property. You chain expectations directly off\n  it:\n  ```dart\n  check(actual).isA\u003CPerson>().has((p) => p.name, 'name').startsWith('A');\n  ```\n\n### 5. Synchronous vs. Asynchronous `throws`\n- **Legacy Matcher**: In `package:matcher`, `throwsA` behaved similarly for both\n  synchronous closures and asynchronous futures when wrapped in `expect` or\n  `expectLater`.\n- **Package Checks**: The `.throws\u003CE>()` expectation behaves differently and\n  has different return types depending on whether the subject is synchronous or\n  asynchronous:\n  - **Synchronous** (`Subject\u003CT Function()>`): `.throws\u003CE>()` returns a\n    `Subject\u003CE>` synchronously. This **does not** accept a callback argument!\n    You chain or cascade expectations directly off the returned `Subject\u003CE>`:\n    ```dart\n    \u002F\u002F YES (Synchronous chaining)\n    check(() => triggerSyncError()).throws\u003CArgumentError>()\n      ..has((e) => e.message, 'message').equals('invalid input');\n\n    \u002F\u002F NO (Passing a callback to sync throws will cause a compiler error!)\n    check(() => triggerSync\").throws\u003CArgumentError>((it) => ...); \u002F\u002F ERROR!\n    ```\n  - **Asynchronous** (`Subject\u003CFuture\u003CT>>`): `.throws\u003CE>()` returns\n    `Future\u003Cvoid>`. Because you cannot chain directly off a `Future\u003Cvoid>`, this\n    **requires** an inspection callback:\n    ```dart\n    \u002F\u002F YES (Asynchronous callback)\n    await check(triggerAsyncError()).throws\u003CArgumentError>((it) => it\n      ..has((e) => e.message, 'message').equals('invalid input'));\n    ```\n  - **Crucial Pitfall**: Trying to chain expectations directly after an awaited\n    asynchronous `.throws\u003CE>()` (e.g.,\n    `await check(future).throws\u003CE>().equals(...)`) will fail to compile\n    because it returns `Future\u003Cvoid>`.\n\n### 6. RegExp \u002F Pattern Equality\n- **Legacy Matcher**: In `package:matcher`, `expect(myPattern,`\n  `equals(RegExp('Hello')))` worked because the matcher comparison rules\n  handled RegExp instances.\n- **Package Checks**: `.equals()` uses strict Dart `==` equality. Since separate\n  `RegExp` instances do not satisfy `==`, using `.equals()` will fail at runtime.\n- **Remediation**: Use `.isA\u003CRegExp>()` type refinement along with cascades to\n  assert on the properties of the `RegExp` object explicitly:\n  ```dart\n  check(myPattern).isA\u003CRegExp>()\n    ..has((r) => r.pattern, 'pattern').equals('Hello')\n    ..has((r) => r.isMultiLine, 'isMultiLine').isTrue();\n  ```\n\n### 7. Strict Nullable Boolean Safety (`bool?` fields)\n- **Legacy Matcher**: Statically, `isTrue` and `isFalse` performed loose\n  dynamic checks at runtime, which silently accepted nullable booleans (`bool?`).\n- **Package Checks**: `.isTrue()` and `.isFalse()` are defined strictly on\n  `Subject\u003Cbool>` (non-nullable). They are **not** available on `Subject\u003Cbool?>`.\n- **Remediation**: For fields declared as `bool?`, you must either refine the\n  subject (e.g., `.isNotNull().isTrue()`) or simply use `.equals(true)` and\n  `.equals(false)` which are generic and work on all types:\n  ```dart\n  \u002F\u002F If options.flagOutdated is a bool?\n  check(options.flagOutdated).equals(true);\n  check(options.flagOutdated).equals(false);\n  ```\n\n### 8. Map Key Containment (`containsKey` vs `contains`)\n- **Legacy Matcher**: In `package:matcher`, `contains(key)` was used to assert\n  that a `Map` contained a specific key.\n- **Package Checks**: Calling `.contains(...)` on a `Subject\u003CMap>` is not\n  defined and will fail compilation.\n- **Remediation**: Use the map-specific `.containsKey(key)` matcher instead:\n  ```dart\n  \u002F\u002F BEFORE (Matcher)\n  expect(myMap, contains('my_key'));\n\n  \u002F\u002F AFTER (Checks)\n  check(myMap).containsKey('my_key');\n  ```\n\n### 9. Explicit Generic Parameters for Extension Types\n- **Legacy Matcher**: `expect(extensionTypeConst, 3)` compiled because of loose\n  dynamic equality.\n- **Package Checks**: If `QrEciValue` is an extension type representation of `int`\n  (e.g., `extension type const QrEciValue(int value) implements int`), calling\n  `.equals(3)` on a `Subject\u003CQrEciValue>` fails because `3` (an `int`) is not\n  assignable to `QrEciValue`. Casting with `as int` will trigger an\n  \"Unnecessary cast\" static analysis warning because `QrEciValue` statically\n  implements `int`.\n- **Remediation**: Explicitly specify the generic type parameter on the `check`\n  function to force checks to treat it as the primitive type:\n  ```dart\n  \u002F\u002F YES (Type-safe and warning-free)\n  check\u003Cint>(QrEciValue.iso8859_1).equals(3);\n  ```\n\n### 10. Dynamic Map \u002F JSON Lookup Casting\n- **Legacy Matcher**: Loose dynamic typing allowed comparing nested json lookups\n  statically typed as `dynamic` directly against lists or maps.\n- **Package Checks**: Strict type safety rejects the implicit assignment of\n  `dynamic` to `Iterable\u003CObject?>` in `.deepEquals(...)`.\n- **Remediation**: Statically cast the dynamic lookup result to a `List` or `Map`:\n  ```dart\n  \u002F\u002F YES (Explicit cast to List)\n  check(myIterable).deepEquals(json['data']['items'] as List);\n  ```\n\n---\n\n## Matcher-to-Checks Mapping Table\n\nUse this table as a quick reference for direct matcher replacements:\n\n| Legacy Matcher | Package Checks Equivalent | Notes |\n| :--- | :--- | :--- |\n| `expect(actual, expected)` | `check(actual).equals(expected)` | Use `.deepEquals` for collections! |\n| `expect(actual, equals(expected))` | `check(actual).equals(expected)` | Use `.deepEquals` for collections! |\n| `isA\u003CT>()` | `check(actual).isA\u003CT>()` | Chaining is supported directly |\n| `same(expected)` | `check(actual).identicalTo(expected)` | Verifies identity |\n| `anyElement(matcher)` | `check(iterable).any(conditionCallback)` | E.g. `check(list).any((e) => e.equals(1))` |\n| `everyElement(matcher)` | `check(iterable).every(conditionCallback)` | E.g. `check(list).every((e) => e.isGreaterThan(0))` |\n| `hasLength(expected)` | `check(actual).length.equals(expected)` | Works on String, Map, Iterable, etc. |\n| `isNot(matcher)` | `check(actual).not(conditionCallback)` | E.g. `check(val).not((it) => it.equals(5))` |\n| `contains(element)` | `check(actual).contains(element)` | Works on String, Iterable (use `containsKey` for Map!) |\n| `contains(key)` (on a Map) | `check(map).containsKey(key)` | Map key containment |\n| `startsWith(prefix)` | `check(string).startsWith(prefix)` | String only |\n| `endsWith(suffix)` | `check(string).endsWith(suffix)` | String only |\n| `isEmpty` | `check(actual).isEmpty()` | Works on String, Map, Iterable |\n| `isNotEmpty` | `check(actual).isNotEmpty()` | Works on String, Map, Iterable |\n| `isNull` | `check(actual).isNull()` | |\n| `isNotNull` | `check(actual).isNotNull()` | |\n| `isTrue` \u002F `true` | `check(actual).isTrue()` | Works on non-nullable `bool` only |\n| `isFalse` \u002F `false` | `check(actual).isFalse()` | Works on non-nullable `bool` only |\n| `completion(matcher)` | `await check(future).completes(conditionCallback)` | Must be awaited! |\n| `throwsA(matcher)` | `await check(future).throws\u003CType>()` | Must be awaited! |\n| `emits(value)` | `await check(streamQueue).emits(conditionCallback)` | Must be awaited! |\n| `emitsThrough(value)` | `await check(streamQueue).emitsThrough(conditionCallback)` | Must be awaited! |\n| `stringContainsInOrder(list)` | `check(string).containsInOrder(list)` | String only |\n| `pairwiseCompare(...)` | `check(actual).pairwiseMatches(...)` | |\n\n---\n\n## Matchers with No Direct Replacements\n\nSome legacy matchers do not have a one-to-one equivalent in `package:checks`\ndue to API cleanup. Use these standard workarounds:\n\n### 1. Specific Error Matchers\n- **Legacy**: `throwsArgumentError`, `throwsStateError`,\n  `throwsUnsupportedError`, etc.\n- **Checks**: Use `.throws\u003CT>()` with the specific error type:\n  ```dart\n  await check(triggerError()).throws\u003CArgumentError>();\n  ```\n\n### 2. The `anything` Matcher\n- **Legacy**: `expect(actual, anything)`\n- **Checks**: Pass an empty condition callback `(_) {}` when a condition is\n  syntactically required:\n  ```dart\n  await check(someFuture).completes((_) {});\n  ```\n\n### 3. Specific Numeric Toggles\n- **Legacy**: `isPositive`, `isNegative`, `isZero`, `isNonPositive`,\n  `isNonNegative`, `isNonZero`\n- **Checks**: Use explicit comparative expectations:\n  - `isPositive` $\\rightarrow$ `isGreaterThan(0)`\n  - `isNegative` $\\rightarrow$ `isLessThan(0)`\n  - `isZero` $\\rightarrow$ `equals(0)`\n  - `isNonNegative` $\\rightarrow$ `isGreaterOrEqual(0)`\n\n### 4. Numeric Ranges\n- **Legacy**: `inClosedOpenRange(min, max)`, `inInclusiveRange(min, max)`,\n  etc.\n- **Checks**: Chain the boundaries using the cascade operator (`..`):\n  ```dart\n  check(actualValue)\n    ..isGreaterOrEqual(min)\n    ..isLessThan(max);\n  ```\n\n---\n\n## Writing Custom Expectations (Replacing Custom Matchers)\n\nWhen migrating from a legacy codebase, you may encounter custom `Matcher`\nsubclasses. In `package:checks`, custom assertions are implemented as\n`extension` methods on `Subject\u003CT>`.\n\nTo write custom expectations, you must import the checks context API:\n```dart\nimport 'package:checks\u002Fcontext.dart';\n```\n\n### 1. Simple Custom Expectations (using `expect`)\nUse `context.expect` to check a property and return a `Rejection` on failure:\n```dart\nextension CustomPersonChecks on Subject\u003CPerson> {\n  void isAdult() {\n    context.expect(\n      () => ['is an adult (age >= 18)'],\n      (actual) {\n        if (actual.age >= 18) return null; \u002F\u002F Pass\n        return Rejection(\n          which: ['is only ${actual.age} years old'],\n        );\n      },\n    );\n  }\n}\n```\n\n### 2. Nested Property Extraction (using `nest` or `has`)\nTo extract a property and allow further chained checks, use `nest` or the\nsimpler `has` helper:\n- **Using `has` (Recommended for simple, non-failing field access)**:\n  ```dart\n  extension CustomPersonChecks on Subject\u003CPerson> {\n    Subject\u003CAddress> get address => has((p) => p.address, 'address');\n  }\n  ```\n- **Using `nest` (For property extraction that can fail or reject)**:\n  ```dart\n  extension CustomPersonChecks on Subject\u003CPerson> {\n    Subject\u003CString> get ssn => context.nest(\n      'has a valid SSN',\n      (actual) {\n        final ssnValue = actual.ssn;\n        if (ssnValue == null) {\n          return Extracted.rejection(which: ['has no SSN']);\n        }\n        return Extracted.value(ssnValue);\n      },\n    );\n  }\n  ```\n\n### 3. Asynchronous Custom Expectations\nIf the expectation is asynchronous (e.g. checking a Future or Stream), use\n`context.expectAsync` or `context.nestAsync` and return the resulting `Future`:\n```dart\nextension CustomFutureChecks\u003CT> on Subject\u003CFuture\u003CT>> {\n  Future\u003Cvoid> completesNormally() {\n    return context.expectAsync(\n      () => ['completes without throwing'],\n      (actual) async {\n        try {\n          await actual;\n          return null; \u002F\u002F Pass\n        } catch (e) {\n          return Rejection(which: ['threw $e']);\n        }\n      },\n    );\n  }\n}\n```\n\n---\n\n## Strategies for Discovery\n\nExecute these commands in the terminal to identify legacy matchers and files\nrequiring migration:\n\n```bash\n# 1. Find all test files containing legacy expect() or expectLater()\ngrep -rn \"expect(\" test\u002F\ngrep -rn \"expectLater(\" test\u002F\n\n# 2. Find potential collection equality pitfalls (literal lists or maps)\ngrep -rn \"expect(.*, \\[\" test\u002F\ngrep -rn \"expect(.*, {\" test\u002F\n\n# 3. Find matches() calls (need conversion to RegExp + matchesPattern)\ngrep -rn \"matches(\" test\u002F\n\n# 4. Find legacy TypeMatcher.having() calls (which need conversion to .has())\ngrep -rn \"having(\" test\u002F\n```\n\n---\n\n## Examples\n\n### Basic Assertions\n**Before (Matcher):**\n```dart\nexpect(someValue, isNotNull);\nexpect(result, isTrue, reason: 'should be successful');\nexpect(myString, startsWith('hello'));\n```\n\n**After (Checks):**\n```dart\ncheck(someValue).isNotNull();\ncheck(because: 'should be successful', result).isTrue();\ncheck(myString).startsWith('hello');\n```\n\n### Collection and Deep Equality\n**Before (Matcher):**\n```dart\nexpect(items, [1, 2, 3]);\nexpect(configMap, equals({'port': 8080}));\n```\n\n**After (Checks):**\n```dart\ncheck(items).deepEquals([1, 2, 3]);\ncheck(configMap).deepEquals({'port': 8080});\n```\n\n### Chaining and Cascades\n**Before (Matcher):**\n```dart\nexpect(someString, allOf([\n  startsWith('a'),\n  contains('b'),\n  endsWith('c'),\n]));\n```\n\n**After (Checks):**\n```dart\ncheck(someString)\n  ..startsWith('a')\n  ..contains('b')\n  ..endsWith('c');\n```\n\n### Complex Property Matching (has)\n**Before (Matcher):**\n```dart\nexpect(response, isA\u003CResponse>()\n    .having((r) => r.statusCode, 'statusCode', 200)\n    .having((r) => r.body, 'body', contains('success')));\n```\n\n**After (Checks):**\n```dart\ncheck(response).isA\u003CResponse>()\n  ..has((r) => r.statusCode, 'statusCode').equals(200)\n  ..has((r) => r.body, 'body').contains('success');\n```\n\n### Asynchronous Futures\n**Before (Matcher):**\n```dart\nexpect(fetchData(), completes);\nexpect(fetchData(), completion(equals('data')));\nexpect(failingCall(), throwsA(isA\u003CStateError>()));\n```\n\n**After (Checks):**\n```dart\nawait check(fetchData()).completes();\nawait check(fetchData()).completes((it) => it.equals('data'));\nawait check(failingCall()).throws\u003CStateError>();\n```\n\n### Asynchronous Streams\n**Before (Matcher):**\n```dart\nvar queue = StreamQueue(Stream.fromIterable([1, 2, 3]));\nawait expectLater(queue, emitsInOrder([1, 2, 3]));\n```\n\n**After (Checks):**\n```dart\nvar queue = StreamQueue(Stream.fromIterable([1, 2, 3]));\nawait check(queue).inOrder([\n  (s) => s.emits((e) => e.equals(1)),\n  (s) => s.emits((e) => e.equals(2)),\n  (s) => s.emits((e) => e.equals(3)),\n]);\n```\n","# Migrating Dart Tests to Package Checks\n\nUse this skill when you need to migrate a Dart test suite from the legacy\n`package:matcher` (which is exported by default from `package:test\u002Ftest.dart`)\nto the modern, type-safe, and literate `package:checks` assertion library.\n\n## Contents\n- [When to Use This Skill](#when-to-use-this-skill)\n- [How to Use This Skill (The Workflow)](#how-to-use-this-skill-the-workflow)\n- [Key Syntax Differences and Pitfalls](#key-syntax-differences-and-pitfalls)\n- [Matcher-to-Checks Mapping Table](#matcher-to-checks-mapping-table)\n- [Matchers with No Direct Replacements](#matchers-with-no-direct-replacements)\n- [Strategies for Discovery](#strategies-for-discovery)\n- [Examples](#examples)\n\n---\n\n## When to Use This Skill\n- When asked to \"migrate tests to checks\", \"use package:checks\", or\n  \"modernize test assertions\".\n- When updating legacy test suites where static type safety, better\n  autocomplete in IDEs, and highly detailed failure diagnostics are desired.\n\n---\n\n## How to Use This Skill (The Workflow)\n\nFollow this structured workflow to safely and systematically migrate a test suite:\n\n### 1. Dependency Setup\n- Add `package:checks` as a `dev_dependency` in `pubspec.yaml`:\n  ```bash\n  dart pub add dev:checks\n  ```\n- Remove `package:matcher` if it is explicitly listed under `dev_dependencies`\n  (it is typically transitively included by `package:test`, which is fine).\n\n### 2. Identify and Plan Target Files\n- Use the grep patterns in [Strategies for Discovery](#strategies-for-discovery)\n  to locate all test files containing legacy `expect` or `expectLater` calls.\n- Decide whether to migrate files fully or incrementally.\n\n### 3. Migrating a File (Incremental or Full)\nFor any target test file:\n1. **Update Imports**:\n   - Replace the generic `import 'package:test\u002Ftest.dart';` with:\n     ```dart\n     import 'package:test\u002Fscaffolding.dart';\n     import 'package:checks\u002Fchecks.dart';\n     ```\n   - **For Incremental Migration**: If you only want to migrate some test cases\n     in the file, or want to migrate one step at a time, add:\n     ```dart\n     import 'package:test\u002Fexpect.dart'; \u002F\u002F Temporarily allows legacy expect()\n     ```\n2. **Translate Assertions**: Rewrite legacy `expect` and `expectLater` calls\n   to `check` syntax following the [Key Syntax Differences and\n   Pitfalls](#key-syntax-differences-and-pitfalls) and the\n   [Matcher-to-Checks Mapping Table](#matcher-to-checks-mapping-table).\n3. **Verify via Compiler**: If migrating fully, remove the `import\n   'package:test\u002Fexpect.dart';` line. Any remaining un-migrated `expect`\n   calls will immediately surface as compiler errors, making them easy to\n   find and fix.\n\n### 4. Verification and Feedback Loops\n- **Static Analysis**: Run static analysis on the target package:\n  ```bash\n  dart analyze\n  ```\n  Pay close attention to generic type parameters on `.isA\u003CType>()` and\n  ensure asynchronous expectations are properly awaited (check for\n  `unawaited_futures` warnings).\n- **Run Tests**: Execute the tests to verify both behavior and correct\n  assertion runtime logic:\n  ```bash\n  dart test\n  ```\n  If a test fails, review the extremely detailed failure output of\n  `package:checks` to diagnose if the test is genuinely failing or if the\n  expectation was translated incorrectly.\n\n---\n\n## Key Syntax Differences and Pitfalls\n\n> [!IMPORTANT]\n> A line-for-line translation can sometimes introduce subtle bugs or false\n> passes. Always review these key differences carefully:\n\n### 1. Collection Equality Pitfall (`equals` vs `deepEquals`)\n- **Legacy Matcher**: `expect(actual, expected)` or `expect(actual,\n  equals(expected))` performed a **deep equality check** if the arguments\n  were collections (Lists, Maps, Sets).\n- **Package Checks**: `.equals(expected)` corresponds strictly to\n  `operator ==`. Since Dart collections do not override `operator ==` for\n  element-wise comparison, using `.equals` on a collection will check for\n  *identity* and almost certainly fail at runtime.\n- **Remediation**: You **must** replace collection equality assertions with\n  `.deepEquals(expected)`.\n  ```dart\n  \u002F\u002F BEFORE (Matcher)\n  expect(myList, [1, 2, 3]);\n\n  \u002F\u002F AFTER (Checks)\n  check(myList).deepEquals([1, 2, 3]);\n  ```\n\n### 2. The `reason` Parameter is now `because`\n- **Legacy Matcher**: The explanation was passed as a trailing named\n  argument `reason` to `expect`:\n  ```dart\n  expect(actual, expectation, reason: 'Explanation');\n  ```\n- **Package Checks**: The explanation is passed as the named argument\n  `because` to the `check` function *before* the actual subject:\n  ```dart\n  check(because: 'Explanation', actual).expectation();\n  ```\n\n### 3. Regular Expression Matching (`matches` vs `matchesPattern`)\n- **Legacy Matcher**: The `matches(pattern)` matcher automatically converted\n  a `String` argument into a `RegExp` (e.g., `matches(r'\\d')` matched `'1'`).\n- **Package Checks**: `.matchesPattern(pattern)` treats a `String` argument\n  as a literal string pattern.\n- **Remediation**: To match using a regular expression, you must explicitly\n  pass a `RegExp` object:\n  ```dart\n  \u002F\u002F BEFORE (Matcher)\n  expect(someString, matches(r'\\d+'));\n\n  \u002F\u002F AFTER (Checks)\n  check(someString).matchesPattern(RegExp(r'\\d+'));\n  ```\n\n### 4. Property Extraction (`TypeMatcher.having` vs `.has`)\n- **Legacy Matcher**: Chained field\u002Fproperty expectations used\n  `TypeMatcher.having(feature, description, matcher)`:\n  ```dart\n  expect(actual, isA\u003CPerson>().having((p) => p.name, 'name', startsWith('A')));\n  ```\n- **Package Checks**: The `.has(feature, description)` extension is\n  available on all `Subject`s, takes one fewer argument, and returns a new\n  `Subject` representing that property. You chain expectations directly off\n  it:\n  ```dart\n  check(actual).isA\u003CPerson>().has((p) => p.name, 'name').startsWith('A');\n  ```\n\n### 5. Synchronous vs. Asynchronous `throws`\n- **Legacy Matcher**: In `package:matcher`, `throwsA` behaved similarly for both\n  synchronous closures and asynchronous futures when wrapped in `expect` or\n  `expectLater`.\n- **Package Checks**: The `.throws\u003CE>()` expectation behaves differently and\n  has different return types depending on whether the subject is synchronous or\n  asynchronous:\n  - **Synchronous** (`Subject\u003CT Function()>`): `.throws\u003CE>()` returns a\n    `Subject\u003CE>` synchronously. This **does not** accept a callback argument!\n    You chain or cascade expectations directly off the returned `Subject\u003CE>`:\n    ```dart\n    \u002F\u002F YES (Synchronous chaining)\n    check(() => triggerSyncError()).throws\u003CArgumentError>()\n      ..has((e) => e.message, 'message').equals('invalid input');\n\n    \u002F\u002F NO (Passing a callback to sync throws will cause a compiler error!)\n    check(() => triggerSync\").throws\u003CArgumentError>((it) => ...); \u002F\u002F ERROR!\n    ```\n  - **Asynchronous** (`Subject\u003CFuture\u003CT>>`): `.throws\u003CE>()` returns\n    `Future\u003Cvoid>`. Because you cannot chain directly off a `Future\u003Cvoid>`, this\n    **requires** an inspection callback:\n    ```dart\n    \u002F\u002F YES (Asynchronous callback)\n    await check(triggerAsyncError()).throws\u003CArgumentError>((it) => it\n      ..has((e) => e.message, 'message').equals('invalid input'));\n    ```\n  - **Crucial Pitfall**: Trying to chain expectations directly after an awaited\n    asynchronous `.throws\u003CE>()` (e.g.,\n    `await check(future).throws\u003CE>().equals(...)`) will fail to compile\n    because it returns `Future\u003Cvoid>`.\n\n### 6. RegExp \u002F Pattern Equality\n- **Legacy Matcher**: In `package:matcher`, `expect(myPattern,`\n  `equals(RegExp('Hello')))` worked because the matcher comparison rules\n  handled RegExp instances.\n- **Package Checks**: `.equals()` uses strict Dart `==` equality. Since separate\n  `RegExp` instances do not satisfy `==`, using `.equals()` will fail at runtime.\n- **Remediation**: Use `.isA\u003CRegExp>()` type refinement along with cascades to\n  assert on the properties of the `RegExp` object explicitly:\n  ```dart\n  check(myPattern).isA\u003CRegExp>()\n    ..has((r) => r.pattern, 'pattern').equals('Hello')\n    ..has((r) => r.isMultiLine, 'isMultiLine').isTrue();\n  ```\n\n### 7. Strict Nullable Boolean Safety (`bool?` fields)\n- **Legacy Matcher**: Statically, `isTrue` and `isFalse` performed loose\n  dynamic checks at runtime, which silently accepted nullable booleans (`bool?`).\n- **Package Checks**: `.isTrue()` and `.isFalse()` are defined strictly on\n  `Subject\u003Cbool>` (non-nullable). They are **not** available on `Subject\u003Cbool?>`.\n- **Remediation**: For fields declared as `bool?`, you must either refine the\n  subject (e.g., `.isNotNull().isTrue()`) or simply use `.equals(true)` and\n  `.equals(false)` which are generic and work on all types:\n  ```dart\n  \u002F\u002F If options.flagOutdated is a bool?\n  check(options.flagOutdated).equals(true);\n  check(options.flagOutdated).equals(false);\n  ```\n\n### 8. Map Key Containment (`containsKey` vs `contains`)\n- **Legacy Matcher**: In `package:matcher`, `contains(key)` was used to assert\n  that a `Map` contained a specific key.\n- **Package Checks**: Calling `.contains(...)` on a `Subject\u003CMap>` is not\n  defined and will fail compilation.\n- **Remediation**: Use the map-specific `.containsKey(key)` matcher instead:\n  ```dart\n  \u002F\u002F BEFORE (Matcher)\n  expect(myMap, contains('my_key'));\n\n  \u002F\u002F AFTER (Checks)\n  check(myMap).containsKey('my_key');\n  ```\n\n### 9. Explicit Generic Parameters for Extension Types\n- **Legacy Matcher**: `expect(extensionTypeConst, 3)` compiled because of loose\n  dynamic equality.\n- **Package Checks**: If `QrEciValue` is an extension type representation of `int`\n  (e.g., `extension type const QrEciValue(int value) implements int`), calling\n  `.equals(3)` on a `Subject\u003CQrEciValue>` fails because `3` (an `int`) is not\n  assignable to `QrEciValue`. Casting with `as int` will trigger an\n  \"Unnecessary cast\" static analysis warning because `QrEciValue` statically\n  implements `int`.\n- **Remediation**: Explicitly specify the generic type parameter on the `check`\n  function to force checks to treat it as the primitive type:\n  ```dart\n  \u002F\u002F YES (Type-safe and warning-free)\n  check\u003Cint>(QrEciValue.iso8859_1).equals(3);\n  ```\n\n### 10. Dynamic Map \u002F JSON Lookup Casting\n- **Legacy Matcher**: Loose dynamic typing allowed comparing nested json lookups\n  statically typed as `dynamic` directly against lists or maps.\n- **Package Checks**: Strict type safety rejects the implicit assignment of\n  `dynamic` to `Iterable\u003CObject?>` in `.deepEquals(...)`.\n- **Remediation**: Statically cast the dynamic lookup result to a `List` or `Map`:\n  ```dart\n  \u002F\u002F YES (Explicit cast to List)\n  check(myIterable).deepEquals(json['data']['items'] as List);\n  ```\n\n---\n\n## Matcher-to-Checks Mapping Table\n\nUse this table as a quick reference for direct matcher replacements:\n\n| Legacy Matcher | Package Checks Equivalent | Notes |\n| :--- | :--- | :--- |\n| `expect(actual, expected)` | `check(actual).equals(expected)` | Use `.deepEquals` for collections! |\n| `expect(actual, equals(expected))` | `check(actual).equals(expected)` | Use `.deepEquals` for collections! |\n| `isA\u003CT>()` | `check(actual).isA\u003CT>()` | Chaining is supported directly |\n| `same(expected)` | `check(actual).identicalTo(expected)` | Verifies identity |\n| `anyElement(matcher)` | `check(iterable).any(conditionCallback)` | E.g. `check(list).any((e) => e.equals(1))` |\n| `everyElement(matcher)` | `check(iterable).every(conditionCallback)` | E.g. `check(list).every((e) => e.isGreaterThan(0))` |\n| `hasLength(expected)` | `check(actual).length.equals(expected)` | Works on String, Map, Iterable, etc. |\n| `isNot(matcher)` | `check(actual).not(conditionCallback)` | E.g. `check(val).not((it) => it.equals(5))` |\n| `contains(element)` | `check(actual).contains(element)` | Works on String, Iterable (use `containsKey` for Map!) |\n| `contains(key)` (on a Map) | `check(map).containsKey(key)` | Map key containment |\n| `startsWith(prefix)` | `check(string).startsWith(prefix)` | String only |\n| `endsWith(suffix)` | `check(string).endsWith(suffix)` | String only |\n| `isEmpty` | `check(actual).isEmpty()` | Works on String, Map, Iterable |\n| `isNotEmpty` | `check(actual).isNotEmpty()` | Works on String, Map, Iterable |\n| `isNull` | `check(actual).isNull()` | |\n| `isNotNull` | `check(actual).isNotNull()` | |\n| `isTrue` \u002F `true` | `check(actual).isTrue()` | Works on non-nullable `bool` only |\n| `isFalse` \u002F `false` | `check(actual).isFalse()` | Works on non-nullable `bool` only |\n| `completion(matcher)` | `await check(future).completes(conditionCallback)` | Must be awaited! |\n| `throwsA(matcher)` | `await check(future).throws\u003CType>()` | Must be awaited! |\n| `emits(value)` | `await check(streamQueue).emits(conditionCallback)` | Must be awaited! |\n| `emitsThrough(value)` | `await check(streamQueue).emitsThrough(conditionCallback)` | Must be awaited! |\n| `stringContainsInOrder(list)` | `check(string).containsInOrder(list)` | String only |\n| `pairwiseCompare(...)` | `check(actual).pairwiseMatches(...)` | |\n\n---\n\n## Matchers with No Direct Replacements\n\nSome legacy matchers do not have a one-to-one equivalent in `package:checks`\ndue to API cleanup. Use these standard workarounds:\n\n### 1. Specific Error Matchers\n- **Legacy**: `throwsArgumentError`, `throwsStateError`,\n  `throwsUnsupportedError`, etc.\n- **Checks**: Use `.throws\u003CT>()` with the specific error type:\n  ```dart\n  await check(triggerError()).throws\u003CArgumentError>();\n  ```\n\n### 2. The `anything` Matcher\n- **Legacy**: `expect(actual, anything)`\n- **Checks**: Pass an empty condition callback `(_) {}` when a condition is\n  syntactically required:\n  ```dart\n  await check(someFuture).completes((_) {});\n  ```\n\n### 3. Specific Numeric Toggles\n- **Legacy**: `isPositive`, `isNegative`, `isZero`, `isNonPositive`,\n  `isNonNegative`, `isNonZero`\n- **Checks**: Use explicit comparative expectations:\n  - `isPositive` $\\rightarrow$ `isGreaterThan(0)`\n  - `isNegative` $\\rightarrow$ `isLessThan(0)`\n  - `isZero` $\\rightarrow$ `equals(0)`\n  - `isNonNegative` $\\rightarrow$ `isGreaterOrEqual(0)`\n\n### 4. Numeric Ranges\n- **Legacy**: `inClosedOpenRange(min, max)`, `inInclusiveRange(min, max)`,\n  etc.\n- **Checks**: Chain the boundaries using the cascade operator (`..`):\n  ```dart\n  check(actualValue)\n    ..isGreaterOrEqual(min)\n    ..isLessThan(max);\n  ```\n\n---\n\n## Writing Custom Expectations (Replacing Custom Matchers)\n\nWhen migrating from a legacy codebase, you may encounter custom `Matcher`\nsubclasses. In `package:checks`, custom assertions are implemented as\n`extension` methods on `Subject\u003CT>`.\n\nTo write custom expectations, you must import the checks context API:\n```dart\nimport 'package:checks\u002Fcontext.dart';\n```\n\n### 1. Simple Custom Expectations (using `expect`)\nUse `context.expect` to check a property and return a `Rejection` on failure:\n```dart\nextension CustomPersonChecks on Subject\u003CPerson> {\n  void isAdult() {\n    context.expect(\n      () => ['is an adult (age >= 18)'],\n      (actual) {\n        if (actual.age >= 18) return null; \u002F\u002F Pass\n        return Rejection(\n          which: ['is only ${actual.age} years old'],\n        );\n      },\n    );\n  }\n}\n```\n\n### 2. Nested Property Extraction (using `nest` or `has`)\nTo extract a property and allow further chained checks, use `nest` or the\nsimpler `has` helper:\n- **Using `has` (Recommended for simple, non-failing field access)**:\n  ```dart\n  extension CustomPersonChecks on Subject\u003CPerson> {\n    Subject\u003CAddress> get address => has((p) => p.address, 'address');\n  }\n  ```\n- **Using `nest` (For property extraction that can fail or reject)**:\n  ```dart\n  extension CustomPersonChecks on Subject\u003CPerson> {\n    Subject\u003CString> get ssn => context.nest(\n      'has a valid SSN',\n      (actual) {\n        final ssnValue = actual.ssn;\n        if (ssnValue == null) {\n          return Extracted.rejection(which: ['has no SSN']);\n        }\n        return Extracted.value(ssnValue);\n      },\n    );\n  }\n  ```\n\n### 3. Asynchronous Custom Expectations\nIf the expectation is asynchronous (e.g. checking a Future or Stream), use\n`context.expectAsync` or `context.nestAsync` and return the resulting `Future`:\n```dart\nextension CustomFutureChecks\u003CT> on Subject\u003CFuture\u003CT>> {\n  Future\u003Cvoid> completesNormally() {\n    return context.expectAsync(\n      () => ['completes without throwing'],\n      (actual) async {\n        try {\n          await actual;\n          return null; \u002F\u002F Pass\n        } catch (e) {\n          return Rejection(which: ['threw $e']);\n        }\n      },\n    );\n  }\n}\n```\n\n---\n\n## Strategies for Discovery\n\nExecute these commands in the terminal to identify legacy matchers and files\nrequiring migration:\n\n```bash\n# 1. Find all test files containing legacy expect() or expectLater()\ngrep -rn \"expect(\" test\u002F\ngrep -rn \"expectLater(\" test\u002F\n\n# 2. Find potential collection equality pitfalls (literal lists or maps)\ngrep -rn \"expect(.*, \\[\" test\u002F\ngrep -rn \"expect(.*, {\" test\u002F\n\n# 3. Find matches() calls (need conversion to RegExp + matchesPattern)\ngrep -rn \"matches(\" test\u002F\n\n# 4. Find legacy TypeMatcher.having() calls (which need conversion to .has())\ngrep -rn \"having(\" test\u002F\n```\n\n---\n\n## Examples\n\n### Basic Assertions\n**Before (Matcher):**\n```dart\nexpect(someValue, isNotNull);\nexpect(result, isTrue, reason: 'should be successful');\nexpect(myString, startsWith('hello'));\n```\n\n**After (Checks):**\n```dart\ncheck(someValue).isNotNull();\ncheck(because: 'should be successful', result).isTrue();\ncheck(myString).startsWith('hello');\n```\n\n### Collection and Deep Equality\n**Before (Matcher):**\n```dart\nexpect(items, [1, 2, 3]);\nexpect(configMap, equals({'port': 8080}));\n```\n\n**After (Checks):**\n```dart\ncheck(items).deepEquals([1, 2, 3]);\ncheck(configMap).deepEquals({'port': 8080});\n```\n\n### Chaining and Cascades\n**Before (Matcher):**\n```dart\nexpect(someString, allOf([\n  startsWith('a'),\n  contains('b'),\n  endsWith('c'),\n]));\n```\n\n**After (Checks):**\n```dart\ncheck(someString)\n  ..startsWith('a')\n  ..contains('b')\n  ..endsWith('c');\n```\n\n### Complex Property Matching (has)\n**Before (Matcher):**\n```dart\nexpect(response, isA\u003CResponse>()\n    .having((r) => r.statusCode, 'statusCode', 200)\n    .having((r) => r.body, 'body', contains('success')));\n```\n\n**After (Checks):**\n```dart\ncheck(response).isA\u003CResponse>()\n  ..has((r) => r.statusCode, 'statusCode').equals(200)\n  ..has((r) => r.body, 'body').contains('success');\n```\n\n### Asynchronous Futures\n**Before (Matcher):**\n```dart\nexpect(fetchData(), completes);\nexpect(fetchData(), completion(equals('data')));\nexpect(failingCall(), throwsA(isA\u003CStateError>()));\n```\n\n**After (Checks):**\n```dart\nawait check(fetchData()).completes();\nawait check(fetchData()).completes((it) => it.equals('data'));\nawait check(failingCall()).throws\u003CStateError>();\n```\n\n### Asynchronous Streams\n**Before (Matcher):**\n```dart\nvar queue = StreamQueue(Stream.fromIterable([1, 2, 3]));\nawait expectLater(queue, emitsInOrder([1, 2, 3]));\n```\n\n**After (Checks):**\n```dart\nvar queue = StreamQueue(Stream.fromIterable([1, 2, 3]));\nawait check(queue).inOrder([\n  (s) => s.emits((e) => e.equals(1)),\n  (s) => s.emits((e) => e.equals(2)),\n  (s) => s.emits((e) => e.equals(3)),\n]);\n```\n",{"name":5,"metadata":24,"description":7},{"model":25,"last_modified":26},"models\u002Fgemini-3.1-pro-preview","Tue, 09 Jun 2026 19:30:00 GMT","main","228e23386ed058f8a2456399cd68f63999d63adf",".claude\u002Fskills\u002Fdart-migrate-to-checks-package","https:\u002F\u002Fgithub.com\u002Fmictlanix\u002Fmbe-ui","https:\u002F\u002Fgithub.com\u002Fmictlanix","https:\u002F\u002Fmictlanix.com","2026-11-15 04:02:27",{"source":8,"skillName":5,"commands":35,"prompt":45,"zipAvailable":46},[36,39,42],{"tool":37,"command":38},"npx","npx skills add mictlanix\u002Fmbe-ui --skill dart-migrate-to-checks-package",{"tool":40,"command":41},"bunx","bunx skills add mictlanix\u002Fmbe-ui --skill dart-migrate-to-checks-package",{"tool":43,"command":44},"pnpm","pnpm dlx skills add mictlanix\u002Fmbe-ui --skill dart-migrate-to-checks-package","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fmictlanix\u002Fmbe-ui\u002Fblob\u002Fmain\u002F.claude\u002Fskills\u002Fdart-migrate-to-checks-package\u002FSKILL.md",true,[],[49,56,61,68,75,82],{"skillNo":50,"name":51,"nameZh":6,"description":52,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":53,"categories":54,"keywords":55,"publishedAt":19},"01M75QCZHHB42Q7KJTZHQZXZ77","speckit-wireframes-draft","Draw low-fi wireframes for every screen and state the spec describes","https:\u002F\u002Fgithub.com\u002Fmictlanix\u002Fmbe-ui\u002Fblob\u002Fmain\u002F.specify\u002Fextensions\u002Fwireframes\u002F.specify-dev\u002Fagent-commands\u002Fclaude\u002Fspeckit-wireframes-draft\u002FSKILL.md",[],[],{"skillNo":57,"name":51,"nameZh":6,"description":6,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":58,"categories":59,"keywords":60,"publishedAt":19},"01M75QCXRSD7HM7AFZH4HA9E6S","https:\u002F\u002Fgithub.com\u002Fmictlanix\u002Fmbe-ui\u002Fblob\u002Fmain\u002F.claude\u002Fskills\u002Fspeckit-wireframes-draft\u002FSKILL.md",[],[],{"skillNo":62,"name":63,"nameZh":6,"description":64,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":65,"categories":66,"keywords":67,"publishedAt":19},"01M75QCVS17DXXBTQ8DE2SSXVR","speckit-taskstoissues","Convert existing tasks into actionable, dependency-ordered GitHub issues for the feature based on available design artifacts.","https:\u002F\u002Fgithub.com\u002Fmictlanix\u002Fmbe-ui\u002Fblob\u002Fmain\u002F.claude\u002Fskills\u002Fspeckit-taskstoissues\u002FSKILL.md",[],[],{"skillNo":69,"name":70,"nameZh":6,"description":71,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":72,"categories":73,"keywords":74,"publishedAt":19},"01M75QCS3M02XD4PW58EXS6458","speckit-tasks","Generate an actionable, dependency-ordered tasks.md for the feature based on available design artifacts.","https:\u002F\u002Fgithub.com\u002Fmictlanix\u002Fmbe-ui\u002Fblob\u002Fmain\u002F.claude\u002Fskills\u002Fspeckit-tasks\u002FSKILL.md",[],[],{"skillNo":76,"name":77,"nameZh":6,"description":78,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":79,"categories":80,"keywords":81,"publishedAt":19},"01M75QCP9NASXGDNYZF6XYJZBD","speckit-specify","Create or update the feature specification from a natural language feature description.","https:\u002F\u002Fgithub.com\u002Fmictlanix\u002Fmbe-ui\u002Fblob\u002Fmain\u002F.claude\u002Fskills\u002Fspeckit-specify\u002FSKILL.md",[],[],{"skillNo":83,"name":84,"nameZh":6,"description":85,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":86,"categories":87,"keywords":88,"publishedAt":19},"01M75QCKBPS4K60R4YPRQ8HBJ9","speckit-plan","Execute the implementation planning workflow using the plan template to generate design artifacts.","https:\u002F\u002Fgithub.com\u002Fmictlanix\u002Fmbe-ui\u002Fblob\u002Fmain\u002F.claude\u002Fskills\u002Fspeckit-plan\u002FSKILL.md",[],[]]