reis-mobile 0.3.5

package/skills/effective-dart/SKILL.md

@@ -0,0 +1,187 @@
+---
+name: effective-dart
+description: Applies Effective Dart guidelines in Flutter/Dart code. Use when writing or reviewing Dart code for naming conventions, types, style, imports, file structure, usage patterns, documentation, testing, widgets, state management, or performance.
+intents: [review]
+stacks: [flutter]
+source: https://github.com/evanca/flutter-ai-rules
+license: MIT
+---
+
+# Effective Dart Skill
+
+This skill defines how to write idiomatic, high-quality Dart and Flutter code following Effective Dart guidelines.
+
+---
+
+## 1. Naming Conventions
+
+| Kind | Convention | Example |
+|---|---|---|
+| Classes, enums, typedefs, type parameters, extensions | `UpperCamelCase` | `MyWidget`, `UserState` |
+| Packages, directories, source files | `lowercase_with_underscores` | `user_profile.dart` |
+| Import prefixes | `lowercase_with_underscores` | `import '...' as my_prefix;` |
+| Variables, parameters, named parameters, functions | `lowerCamelCase` | `userName`, `fetchData()` |
+
+- Capitalize acronyms and abbreviations longer than two letters like words: `HttpRequest`, not `HTTPRequest`.
+- Avoid abbreviations unless the abbreviation is more common than the full term.
+- Prefer putting the **most descriptive noun last** in names.
+- Use terms **consistently** throughout your code.
+- Follow mnemonic conventions for type parameters: `E` (element), `K`/`V` (key/value), `T`/`S`/`U` (generic types).
+- Consider making code **read like a sentence** when designing APIs.
+- Prefer a **noun phrase** for non-boolean properties or variables.
+- Prefer a **non-imperative verb phrase** for boolean properties or variables; prefer the positive form.
+- Consider omitting the verb for named boolean parameters.
+
+---
+
+## 2. Types and Functions
+
+- Use **class modifiers** to control if a class can be extended or used as an interface.
+- **Type annotate variables** without initializers.
+- Type annotate **fields and top-level variables** if the type isn't obvious.
+- **Annotate return types** on function declarations.
+- **Annotate parameter types** on function declarations.
+- Write **type arguments** on generic invocations that aren't inferred.
+- Annotate with `dynamic` instead of letting inference fail.
+- Use `Future<void>` as the return type of async members that do not produce values.
+- Use **getters** for operations that conceptually access properties.
+- Use **setters** for operations that conceptually change properties.
+- Use a **function declaration** to bind a function to a name.
+- Use **inclusive start and exclusive end** parameters to accept a range.
+
+---
+
+## 3. Style
+
+```bash
+dart format .
+```
+
+- Format code with `dart format` — don't manually format.
+- Use **curly braces** for all flow control statements.
+- Prefer `final` over `var` when variable values won't change.
+- Use `const` for compile-time constants.
+- Prefer lines **80 characters or fewer** for readability.
+
+---
+
+## 4. Imports and Files
+
+- Don't import libraries inside the `src` directory of another package.
+- Don't allow import paths to reach into or out of `lib`.
+- **Prefer relative import paths** within a package.
+- Don't use `/lib/` or `../` in import paths.
+- Consider writing a **library-level doc comment** for library files.
+
+---
+
+## 5. Structure
+
+- Keep files **focused on a single responsibility**.
+- Limit file length to maintain readability.
+- Group related functionality together.
+- Prefer making fields and top-level variables `final`.
+- Consider making constructors `const` if the class supports it.
+- **Prefer making declarations private** — only expose what's necessary.
+
+---
+
+## 6. Usage
+
+```dart
+// Adjacent string concatenation (not +)
+final greeting = 'Hello, '
+    'world!';
+
+// Collection literals
+final list = [1, 2, 3];
+final map = {'key': 'value'};
+
+// Initializing formals
+class Point {
+  final double x, y;
+  Point(this.x, this.y);
+}
+
+// Empty constructor body
+class Empty {
+  Empty();  // not Empty() {}
+}
+
+// rethrow
+try {
+  doSomething();
+} catch (e) {
+  log(e);
+  rethrow;
+}
+```
+
+- Use `whereType()` to filter a collection by type.
+- Follow a **consistent rule** for `var` and `final` on local variables.
+- Initialize fields at their **declaration** when possible.
+- Override `hashCode` if you override `==`; ensure `==` obeys mathematical equality rules.
+- **Prefer specific exception handling**: use `on SomeException catch (e)` instead of broad `catch (e)` or `.catchError` handlers.
+
+---
+
+## 7. Documentation
+
+```dart
+/// Returns the sum of [a] and [b].
+///
+/// Throws [ArgumentError] if either value is negative.
+int add(int a, int b) { ... }
+```
+
+- Format comments like sentences (capitalize, end with period).
+- Use `///` doc comments — not `/* */` block comments — for types and members.
+- Prefer writing doc comments for **public APIs**; consider them for private APIs too.
+- Start doc comments with a **single-sentence summary**, separated into its own paragraph.
+- Avoid redundancy with the surrounding context.
+- Start function/method comments with a **third-person verb** if the main purpose is a side effect.
+- Start with a **noun or non-imperative verb phrase** if returning a value is the primary purpose.
+- Start **boolean** variable/property comments with "Whether followed by a noun or gerund phrase.
+- Use `[identifier]` in doc comments to refer to in-scope identifiers.
+- Use **prose** to explain parameters, return values, and exceptions (e.g., "The [param]", "Returns", "Throws" sections).
+- Put doc comments **before** metadata annotations.
+- Document **why** code exists or how it should be used, not just what it does.
+- When referring to the current object, prefer "this box" over bare "this".
+
+---
+
+## 8. Testing
+
+- Write **unit tests** for business logic.
+- Write **widget tests** for UI components.
+- Aim for **good test coverage**.
+
+---
+
+## 9. Widgets
+
+- Extract reusable widgets into **separate components**.
+- Use `StatelessWidget` when possible.
+- Keep **build methods simple and focused**.
+
+---
+
+## 10. State Management
+
+- Choose appropriate state management based on **complexity**.
+- Avoid unnecessary `StatefulWidget`s.
+- Keep **state as local as possible**.
+
+---
+
+## 11. Performance
+
+- Use `const` constructors when possible.
+- Avoid **expensive operations** in build methods.
+- Implement **pagination** for large lists.
+
+---
+
+## References
+
+- [Dart Site WWW GitHub Repository](https://github.com/dart-lang/site-www)

package/skills/firebase-ai/SKILL.md

@@ -0,0 +1,93 @@
+---
+name: firebase-ai
+description: Integrates Firebase AI Logic into Flutter apps. Use when setting up the firebase_ai plugin, calling Gemini models, handling AI service errors, or applying security and privacy considerations for AI features.
+routing: manual
+stacks: [flutter]
+source: https://github.com/evanca/flutter-ai-rules
+license: MIT
+---
+
+# Firebase AI Skill
+
+This skill defines how to correctly use Firebase AI Logic in Flutter applications.
+
+## When to Use
+
+Use this skill when:
+
+* Setting up and configuring Firebase AI in a Flutter project.
+* Implementing AI features on supported platforms.
+* Handling errors and offline scenarios for AI operations.
+* Applying security and privacy considerations for AI features.
+
+---
+
+## 1. Setup and Configuration
+
+```
+flutter pub add firebase_ai
+```
+
+```dart
+import 'package:firebase_ai/firebase_ai.dart';
+import 'package:firebase_core/firebase_core.dart';
+import 'firebase_options.dart';
+
+// Initialize FirebaseApp
+await Firebase.initializeApp(
+  options: DefaultFirebaseOptions.currentPlatform,
+);
+
+// Initialize the Gemini Developer API backend service
+// Create a GenerativeModel instance with a model that supports your use case
+final model =
+    FirebaseAI.googleAI().generativeModel(model: 'gemini-2.5-flash');
+```
+
+- Ensure your Firebase project is properly configured for AI services (via the Firebase AI Logic page in the Firebase Console).
+- Initialize Firebase before using any Firebase AI features.
+- Use `FirebaseAI.googleAI()` for the **Gemini Developer API** backend (recommended starting point).
+- Consider implementing **App Check** to prevent abuse of your Firebase AI endpoints.
+
+**Platform support:**
+
+| Platform | Support |
+|---|---|
+| iOS | Full |
+| Android | Full |
+| Web | Full |
+| macOS / other Apple | Beta |
+| Windows | Not supported |
+
+---
+
+## 2. Best Practices
+
+- Be aware of **rate limits and quotas** when implementing AI features — monitor usage and costs in the Firebase Console.
+- Handle AI service errors gracefully with appropriate **fallback mechanisms**.
+- Consider **user privacy** when implementing AI features that process user data.
+- Test AI functionality across all supported platforms during development.
+
+---
+
+## 3. Error Handling
+
+- Implement proper error handling for AI service failures.
+- Provide meaningful error messages to users when AI operations fail.
+- Handle **offline scenarios** and implement appropriate fallback behavior.
+- Handle **rate limiting and quota exceeded** errors appropriately.
+
+---
+
+## 4. Security
+
+- Follow Firebase Security Rules best practices when using AI services alongside other Firebase products.
+- Ensure proper **authentication and authorization** for AI feature access.
+- Be mindful of **data privacy requirements** when processing user content with AI services.
+- Implement appropriate **content filtering and moderation** as needed.
+
+---
+
+## References
+
+- [Firebase AI Logic Flutter documentation](https://firebase.google.com/docs/ai-logic/get-started?platform=flutter)

package/skills/firebase-analytics/SKILL.md

@@ -0,0 +1,129 @@
+---
+name: firebase-analytics
+description: Integrates Firebase Analytics into Flutter apps. Use when setting up analytics, logging events, setting user properties, or configuring event parameters.
+routing: manual
+stacks: [flutter]
+source: https://github.com/evanca/flutter-ai-rules
+license: MIT
+---
+
+# Firebase Analytics Skill
+
+This skill defines how to correctly use Firebase Analytics in Flutter applications.
+
+## When to Use
+
+Use this skill when:
+
+* Setting up and configuring Firebase Analytics in a Flutter project.
+* Logging predefined or custom events.
+* Setting user properties or default event parameters.
+* Applying best practices for analytics data collection.
+
+---
+
+## 1. Setup and Configuration
+
+```
+flutter pub add firebase_analytics
+flutter run
+```
+
+```dart
+import 'package:firebase_analytics/firebase_analytics.dart';
+
+// After Firebase.initializeApp():
+FirebaseAnalytics analytics = FirebaseAnalytics.instance;
+```
+
+- Initialize Firebase before using any Firebase Analytics features.
+- Analytics **automatically logs** some events and user properties — no additional code needed for those.
+
+---
+
+## 2. Event Logging
+
+Use **predefined event methods** when possible for maximum detail in reports and access to future Google Analytics features:
+
+```dart
+await FirebaseAnalytics.instance.logSelectContent(
+  contentType: "image",
+  itemId: itemId,
+);
+```
+
+Use the general `logEvent()` method for both predefined and custom events:
+
+```dart
+await FirebaseAnalytics.instance.logEvent(
+  name: "select_content",
+  parameters: {
+    "content_type": "image",
+    "item_id": itemId,
+  },
+);
+```
+
+Custom events:
+
+```dart
+await FirebaseAnalytics.instance.logEvent(
+  name: "share_image",
+  parameters: {
+    "image_name": name,
+    "full_text": text,
+  },
+);
+```
+
+- Event names are **case-sensitive** — names differing only in case create two distinct events.
+- You can log up to **500 different event types** with no limit on total event volume.
+
+---
+
+## 3. Parameters and Properties
+
+- Parameter names: up to **40 characters**, must start with an alphabetic character, contain only alphanumeric characters and underscores.
+- String parameter values: up to **100 characters**.
+- The prefixes `firebase_`, `google_`, and `ga_` are **reserved** — do not use them for parameter names.
+- Use custom parameters for non-numerical data (dimensions) or numerical data (metrics); register them in the Analytics console first.
+
+Set default parameters for all future events (not supported on web):
+
+```dart
+await FirebaseAnalytics.instance.setDefaultEventParameters({
+  'version': '1.2.3',
+});
+```
+
+Clear a default parameter by setting it to `null`.
+
+---
+
+## 4. User Properties
+
+```dart
+await FirebaseAnalytics.instance.setUserProperty(
+  name: 'favorite_food',
+  value: favoriteFood,
+);
+```
+
+- Create custom definitions for user properties in the Analytics console before using them.
+- Use user properties for custom definitions, report comparisons, or audience criteria.
+
+---
+
+## 5. Best Practices
+
+- **Request necessary permissions** before collecting user data, especially on platforms with strict privacy controls.
+- **Never log** sensitive or personally identifiable information in events or user properties.
+- Use **consistent naming conventions** for custom events and parameters.
+- Group related events to track user flows and conversion funnels.
+- **Test** your analytics implementation before deploying to production.
+
+---
+
+## References
+
+- [FlutterFire GitHub Repository](https://github.com/firebase/flutterfire)

package/skills/firebase-app-check/SKILL.md

@@ -0,0 +1,124 @@
+---
+name: firebase-app-check
+description: Integrates Firebase App Check into Flutter apps. Use when setting up App Check, selecting providers per platform, using debug providers during development, enabling enforcement, or applying App Check security best practices.
+intents: [security]
+stacks: [flutter]
+source: https://github.com/evanca/flutter-ai-rules
+license: MIT
+---
+
+# Firebase App Check Skill
+
+This skill defines how to correctly use Firebase App Check in Flutter applications.
+
+## When to Use
+
+Use this skill when:
+
+* Setting up and activating Firebase App Check in a Flutter project.
+* Selecting the right provider for each platform.
+* Configuring debug providers for development and testing.
+* Enabling enforcement and monitoring App Check metrics.
+* Applying App Check security best practices.
+
+---
+
+## 1. Setup and Configuration
+
+```
+flutter pub add firebase_app_check
+```
+
+```dart
+import 'package:firebase_app_check/firebase_app_check.dart';
+```
+
+Initialize App Check **after** `Firebase.initializeApp()` and **before** using any Firebase services:
+
+```dart
+await Firebase.initializeApp();
+await FirebaseAppCheck.instance.activate(
+  webProvider: ReCaptchaV3Provider('recaptcha-v3-site-key'),
+  providerAndroid: AndroidPlayIntegrityProvider(),
+  providerApple: AppleDeviceCheckProvider(),
+);
+```
+
+- Register your apps in the Firebase console under **Project Settings > App Check** before using the service.
+- For web, obtain a reCAPTCHA v3 site key from the Firebase console.
+- Consider setting a custom **TTL** for App Check tokens based on your security and performance needs — shorter TTLs are more secure but consume quota faster.
+
+---
+
+## 2. Provider Selection
+
+**Android:**
+| Provider | Use case |
+|---|---|
+| `AndroidPlayIntegrityProvider` | Production (default) |
+| `AndroidDebugProvider` | Development / CI only |
+
+**Apple (iOS / macOS):**
+| Provider | Use case |
+|---|---|
+| `AppleDeviceCheckProvider` | Production default (iOS 11+, macOS 10.15+) |
+| `AppleAppAttestProvider` | Enhanced security (iOS 14+, macOS 14+) |
+| `AppleAppAttestProviderWithDeviceCheckFallback` | App Attest with Device Check fallback |
+| `AppleDebugProvider` | Development / CI only |
+
+**Web:**
+| Provider | Use case |
+|---|---|
+| `ReCaptchaV3Provider` | Standard reCAPTCHA v3 |
+| `ReCaptchaEnterpriseProvider` | Enhanced with additional features |
+
+> **Android note:** For certain Android devices, enable "Meets basic device integrity" in the Google Play console to ensure proper App Check functionality.
+
+---
+
+## 3. Development and Testing
+
+Use debug providers during development to run in emulators or CI environments:
+
+```dart
+await FirebaseAppCheck.instance.activate(
+  providerAndroid: AndroidDebugProvider('YOUR_DEBUG_TOKEN'),
+  providerApple: AppleDebugProvider('YOUR_DEBUG_TOKEN'),
+);
+```
+
+- **iOS:** Enable debug logging by adding `-FIRDebugEnabled` to Arguments Passed on Launch in Xcode.
+- **Web:** Set `self.FIREBASE_APPCHECK_DEBUG_TOKEN = true;` in `web/index.html`.
+- Register debug tokens shown in the console in the Firebase console's App Check section.
+- **Never** use debug providers or share debug tokens in production builds.
+- Keep debug tokens private — do not commit them to public repositories.
+- Revoke compromised debug tokens immediately from the Firebase console.
+
+---
+
+## 4. Enforcement and Monitoring
+
+- **Monitor** App Check metrics before enabling enforcement to avoid disrupting legitimate users.
+- Enable enforcement **gradually**, starting with non-critical Firebase services.
+- Monitor request metrics for Realtime Database, Cloud Firestore, Cloud Storage, and Authentication.
+- Once enforcement is enabled, only registered apps with valid App Check tokens can access Firebase resources.
+- Use App Check **in combination with** Firebase Security Rules for comprehensive security.
+- Implement proper error handling for App Check verification failures.
+
+---
+
+## 5. Security Best Practices
+
+- Never disable App Check in production builds once enabled.
+- Implement a fallback mechanism for App Check verification failures.
+- Regularly review App Check metrics to identify potential abuse patterns.
+- App Check tokens are **automatically refreshed** at approximately half the TTL duration.
+- For high-security applications, use the shortest practical TTL.
+- Implement server-side verification for critical operations using the Firebase Admin SDK.
+
+---
+
+## References
+
+- [Firebase App Check Flutter documentation](https://firebase.google.com/docs/app-check/flutter/default-providers)
+- [Firebase App Check debug provider](https://firebase.google.com/docs/app-check/flutter/debug-provider)