mobile-ai-agents 1.0.23

package/skills/cross-platform/store-listing.md

@@ -0,0 +1,75 @@
+# Skill — /store-listing
+
+**Platform:** Cross-Platform
+**Slash Command:** `/store-listing`
+**Composable With:** agents/cross-platform/launchpad/agent.md
+
+---
+
+## Purpose
+
+Conversational ASO and growth listing writer. It audits the app baseline, then generates App Store and Play Store metadata, keyword strategy, screenshot/video briefs, and launch-growth recommendations without duplicating platform keywords incorrectly.
+
+---
+
+## Skill Prompt
+
+```
+Generate ASO-optimized store listing copy through a short diagnostic conversation:
+
+ASK THESE QUESTIONS FIRST (wait for answers before generating unless the user already provided them):
+1. App Store / Play Store URL if live, or app name and category if not live.
+2. Target market/region and language. Example: US English, UK English, Brazil Portuguese, Japan Japanese.
+3. Core value proposition in one sentence.
+4. Target user and pain point. Include audience, use case, and purchase intent.
+5. Top 3 features that make users stay.
+6. Top 2-3 competitors or alternatives.
+7. Current stage: idea, pre-launch, newly launched, scaling, or optimization.
+8. Platform(s): Android, iOS, or both.
+9. Monetization: free, ads, subscription, one-time purchase, IAP, or mixed.
+10. Brand tone: professional, friendly, playful, premium, utility, or minimal.
+
+AFTER RECEIVING ANSWERS, GENERATE:
+
+PLAY STORE:
+- Title (30 chars): Brand + primary keyword. Keep it natural and policy-safe.
+- Short Description (80 chars): Primary conversion hook with 1-2 important keywords.
+- Long Description (4000 chars max): Semantic description for Google Play NLP.
+  Primary keyword in the first 167 chars. Maintain roughly 2-3% primary keyword density.
+  Use benefit headers, short paragraphs, bullets, social-proof placeholders, and a CTA.
+- Store Listing Experiments: 2-3 A/B test ideas for title, short description, screenshots, or feature graphic.
+- Promotional Content: event/update/banner idea if relevant.
+
+APP STORE:
+- Name (30 chars): Brand + highest-value keyword if it fits naturally.
+- Subtitle (30 chars): Secondary keyword phrase that complements the name and does not repeat words.
+- Keyword field (100 chars): Comma-separated, no spaces, no repeats from name/subtitle.
+  Break phrases into individual words. Prefer singular form unless plural has distinct intent.
+- Promotional Text (170 chars): Timely update, offer, social proof, or launch hook.
+- Description (4000 chars max): Benefit-first, structured, conversion-focused.
+- Product Page Optimization: 2-3 PPO test ideas for icon, screenshots, preview video, or subtitle.
+- Custom Product Page: one CPP angle mapped to a keyword or campaign.
+- In-App Event: one IAE idea if relevant.
+
+VISUAL + VIDEO BRIEF:
+- Screenshot 1 hero caption and visual.
+- Screenshots 2-5 feature captions and visuals.
+- App preview/promo video concept with the first 3 seconds scripted.
+- YouTube/short-form video distribution ideas if useful for the category.
+
+GROWTH + OFF-STORE SEO:
+- Google Play backlink/PR plan with safe contextual anchor examples.
+- Landing page SEO angle and smart app banner/deep-link recommendation.
+- Directory/community placements such as Product Hunt, AlternativeTo, G2, Capterra, or niche forums where appropriate.
+
+RULES:
+- Character limits are hard limits. Report character counts for every metadata field.
+- Never use competitor names in keyword fields (App Store policy violation)
+- Never use misleading superlatives like "best", "#1", or "world's leading" unless independently verifiable and policy-safe.
+- Singular OR plural in keywords — not both (algorithm handles it)
+- No emoji in Play Store title (against guidelines)
+- Do not keyword-stuff. If density is too high, flag it before submission.
+- Localize separately per market. Do not mix languages in one keyword field unless the market behavior supports it.
+
+Flag any constraint violation before the developer submits.
+```

package/skills/flutter/README.md

@@ -0,0 +1,32 @@
+# Flutter Skills
+
+Reusable skill prompt modules for Flutter (Dart 3.x) widget generation and code review.
+
+## Index
+
+| Skill | File | When to Use |
+|---|---|---|
+| Flutter Widget Generation Rules | [widget-gen.md](widget-gen.md) | Before generating any widget — ensures null-safety, const constructors, theming, accessibility |
+
+## Usage
+
+```
+# Prime any LLM session before widget generation
+[paste skill prompt from widget-gen.md]
+
+Generate a widget for: [describe the widget]
+```
+
+## Composable With
+
+- [`agents/flutter/widget-generator`](../../agents/flutter/widget-generator/) — full structured widget generation
+- [`agents/flutter/bloc-feature-builder`](../../agents/flutter/bloc-feature-builder/) — generate full feature layer
+
+## Contributing
+
+High-value skills to add:
+- `state-management-review.md` — review BLoC, Cubit, Riverpod, Provider patterns
+- `navigation-review.md` — GoRouter, Navigator 2.0 patterns
+- `performance-review.md` — `const` constructors, `ListView.builder`, `RepaintBoundary`
+
+Copy `templates/skill-template.md` and open a PR.

package/skills/flutter/dart-modernize.md

@@ -0,0 +1,47 @@
+# Skill — /dart-modernize
+
+**Platform:** Flutter (Dart 3.x)
+**Slash Command:** `/dart-modernize`
+
+---
+
+## Purpose
+
+Upgrades pre-null-safety or Dart 2.x code to modern Dart 3.x patterns. Introduces records, patterns, sealed classes, and null safety best practices.
+
+---
+
+## Skill Prompt
+
+```
+Modernize the provided Dart code to Dart 3.x idioms:
+
+NULL SAFETY UPGRADES:
+- Remove null assertions (!) where safe alternatives exist.
+- Replace nullable + null check pattern with if-null operator ??.
+- Replace nullable return types with Result<T> pattern or sealed class for error states.
+- late variables: confirm they are always initialized before use; otherwise use nullable.
+
+DART 3.x FEATURES:
+1. Records: replace multi-value tuples, Map<String, dynamic> returns, or pair classes.
+   Before: Map<String, dynamic> getCoords() => {'lat': 1.3, 'lng': 103.8}
+   After: (double lat, double lng) getCoords() => (1.3, 103.8)
+
+2. Patterns + switch expressions:
+   Before: String label(Shape s) { if (s is Circle) return 'circle'; ... }
+   After: String label(Shape s) => switch (s) {
+     Circle() => 'circle', Rectangle() => 'rectangle', _ => 'unknown'
+   };
+
+3. Sealed classes (Dart 3): replace abstract classes used for exhaustive matching.
+   sealed class ApiResult<T> { }
+   final class Success<T> extends ApiResult<T> { final T data; ... }
+   final class Failure<T> extends ApiResult<T> { final Exception error; ... }
+
+4. Class modifiers: add final, base, or interface where appropriate.
+
+5. Extension types: replace thin wrapper classes (value objects) with extension types
+   for zero-cost abstraction.
+
+Show before and after for each transformation.
+```

package/skills/flutter/flutter-review.md

@@ -0,0 +1,59 @@
+# Skill — /flutter-review
+
+**Platform:** Flutter (Dart 3.x)
+**Slash Command:** `/flutter-review`
+**Composable With:** agents/flutter/dart/agent.md
+
+---
+
+## Purpose
+
+Widget tree audit covering const constructors, state management correctness, rebuild scope, and accessibility. Use before PR merge on any Flutter screen or widget.
+
+---
+
+## Skill Prompt
+
+```
+Review the provided Flutter/Dart code for these issues:
+
+CONST CONSTRUCTORS
+- Every widget whose properties are all compile-time constants should be const.
+- Flag every Text('literal'), Icon(Icons.x), SizedBox(height: N) that is missing const.
+- Cost of missing const: unnecessary widget instantiation on every rebuild.
+
+REBUILD SCOPE
+- setState() in a large StatefulWidget that should be scoped to a smaller widget.
+- Consumer/BlocBuilder/Selector wrapping the entire screen body.
+  Fix: wrap only the smallest subtree that actually depends on the changing state.
+- AnimatedBuilder wrapping non-animated children.
+
+STATE MANAGEMENT
+- Business logic in build() method — flag and suggest moving to Bloc/Cubit/Notifier.
+- BuildContext used after async gap without mounted check.
+- StreamBuilder with no initialData and no error handler.
+
+NULL SAFETY
+- Late variables without clear initialization guarantee.
+- ! operator on values that could realistically be null.
+- Dynamic type used where a concrete type is known.
+
+ACCESSIBILITY
+- Images without semanticLabel.
+- Tappable widgets without Semantics(button: true) or semanticsLabel.
+- Touch targets smaller than 48×48dp.
+- Text contrast — flag hardcoded colors that may fail WCAG AA.
+
+DART 3.x PATTERNS
+- switch expressions where applicable (replaces verbose if/else chains).
+- Records for lightweight multi-value returns.
+- Sealed classes for exhaustive state modeling.
+
+For each issue: widget name, line if given, what causes the problem, and the fix.
+```
+
+---
+
+## Demo
+
+<img width="400" height="261" alt="flutter-review demo" src="https://github.com/user-attachments/assets/e0c1d9d8-f66e-4983-a60b-b3b515fa0de0" />

package/skills/flutter/flutter-tdd.md

@@ -0,0 +1,73 @@
+# Skill — /flutter-tdd
+
+**Platform:** Flutter (Dart 3.x)
+**Slash Command:** `/flutter-tdd`
+**Composable With:** agents/flutter/dart/agent.md
+
+---
+
+## Purpose
+
+Runs the red-green-refactor TDD loop for Flutter — widget tests, unit tests, and Bloc/Riverpod tests. Generates failing tests first, then the minimal implementation.
+
+---
+
+## Skill Prompt
+
+```
+Run the Flutter TDD loop for the described feature or widget:
+
+STEP 1 — RED: Write a failing test first.
+- For Dart logic: flutter_test unit test using test(), setUp(), expect().
+- For Widgets: WidgetTester with pumpWidget(), find.*, tap(), enterText().
+- For Bloc: bloc_test package with blocTest<>() — seed state, act, expect.
+- For Riverpod: ProviderContainer with overrides to test providers in isolation.
+
+STEP 2 — GREEN: Write the minimal Dart/Flutter implementation to pass.
+- Smallest possible code. No architecture yet.
+
+STEP 3 — REFACTOR: Apply correct patterns.
+- Extract StatelessWidget, add const, apply BLoC/Riverpod pattern properly.
+
+Format:
+--- RED ---
+<test code>
+
+--- GREEN ---
+<minimal implementation>
+
+--- REFACTOR ---
+<final implementation>
+```
+
+---
+
+## Example
+
+**Input:** "TDD a CartBloc that adds items and tracks total price"
+
+**Output:**
+```dart
+--- RED ---
+blocTest<CartBloc, CartState>(
+  'adding an item increases total price',
+  build: () => CartBloc(),
+  act: (bloc) => bloc.add(AddItem(Item(name: 'Book', price: 15.0))),
+  expect: () => [
+    CartState(items: [Item(name: 'Book', price: 15.0)], total: 15.0),
+  ],
+);
+
+--- GREEN ---
+class CartBloc extends Bloc<CartEvent, CartState> {
+  CartBloc() : super(CartState(items: [], total: 0)) {
+    on<AddItem>((event, emit) {
+      final items = [...state.items, event.item];
+      emit(CartState(items: items, total: items.fold(0, (s, i) => s + i.price)));
+    });
+  }
+}
+
+--- REFACTOR ---
+// Extract total calculation, add @freezed state, equatable events
+```

package/skills/flutter/widget-extract.md

@@ -0,0 +1,41 @@
+# Skill — /widget-extract
+
+**Platform:** Flutter (Dart)
+**Slash Command:** `/widget-extract`
+
+---
+
+## Purpose
+
+Identifies oversized build() methods and extracts them into reusable, testable widget components. Applies the Flutter "extract widget" refactoring pattern correctly.
+
+---
+
+## Skill Prompt
+
+```
+Analyze the provided Flutter widget and extract oversized build() methods into smaller components:
+
+EXTRACTION CRITERIA:
+- build() longer than 60 lines: candidate for extraction.
+- Repeated patterns (2+ similar widget subtrees): candidate for a reusable component.
+- Conditionally rendered subtrees: extract into separate named widgets.
+- List item builder: extract into a dedicated ItemWidget.
+
+EXTRACTION RULES:
+1. Prefer StatelessWidget over methods (extracting into a private _buildX() method is worse
+   than a separate widget — methods don't benefit from widget diffing and add noise).
+2. Pass only the data the child widget needs — not the parent's entire state/model.
+3. Add const constructor to the extracted widget if all fields are final.
+4. Name extracted widgets after their semantic role (not _MyWidgetHeader, but UserProfileHeader).
+
+WHAT NOT TO EXTRACT:
+- Modifier chains (Padding, SizedBox wrappers) — keep inline.
+- Single-child wrappers with no reuse value.
+- Subtrees under 5 lines with no reuse potential.
+
+Output:
+1. List of extraction candidates with justification.
+2. Refactored parent widget.
+3. Each extracted widget as a separate, complete class.
+```

package/skills/flutter/widget-gen.md

@@ -0,0 +1,131 @@
+# Skill — Flutter Widget Generation Rules
+
+**Platform:** Flutter (Dart)  
+**Category:** UI & Design  
+**Composable With:** agents/flutter/widget-generator/agent.md
+
+---
+
+## Purpose
+
+Gives an LLM the rules needed to generate production-quality Flutter widget code. Use as a standalone primer or as a module inside the Widget Generator agent.
+
+## When to Use
+
+- Before asking any LLM to write Flutter widget code
+- When you want quick widget snippets without running the full agent
+- As a quality gate when reviewing AI-generated Flutter code
+
+---
+
+## Skill Prompt
+
+```
+When generating Flutter/Dart widget code, follow these rules:
+
+CORRECTNESS
+- All code must be null-safe (Dart 3.x). Never use the legacy ? suffix on non-nullable types.
+- Prefer `const` constructors wherever possible — this is a Flutter performance requirement,
+  not a style preference. Mark widgets const when all fields are compile-time constants.
+- Call `super.dispose()` in every dispose() override. Failure to do so is a memory leak.
+- Use `super.key` parameter forwarding in constructors: MyWidget({super.key, ...}).
+
+THEMING
+- Never hardcode colors as hex literals (#FF5733) or RGB values (Colors.red). Always use:
+  Theme.of(context).colorScheme.primary (Material 3)
+  Theme.of(context).cardColor
+  Theme.of(context).textTheme.bodyMedium
+- Never hardcode font sizes. Use Theme.of(context).textTheme styles.
+- For spacing, prefer a consistent spacing system (e.g., multiples of 8) using const values.
+
+RESPONSIVE LAYOUT
+- Never hardcode pixel widths for layout. Use:
+  Flexible / Expanded for flex layouts
+  LayoutBuilder for container-relative sizing
+  MediaQuery.of(context).size for screen-relative sizing
+- For text, let it wrap with softWrap: true (default) rather than fixed-width Text containers.
+
+ANIMATIONS
+- For simple show/hide or size changes: AnimatedContainer, AnimatedOpacity, AnimatedSize.
+- For custom animations: AnimationController + SingleTickerProviderStateMixin.
+  Always cancel the controller in dispose(): _controller.dispose().
+- Always check if mounted before calling setState() in async callbacks:
+  if (mounted) setState(() { ... });
+
+ACCESSIBILITY
+- Use Semantics widget to label non-text interactive elements.
+- Ensure all tap targets are at least 48×48 dp (GestureDetector / InkWell padding).
+- Use Tooltip for icon-only buttons.
+
+STATE MANAGEMENT
+- For local UI state: StatefulWidget + setState.
+- For shared state across widgets: use the project's specified state management (Riverpod,
+  Bloc, Provider) — do not mix approaches.
+- Do not put business logic in build(). Business logic belongs in a ViewModel/controller/notifier.
+```
+
+---
+
+## Example
+
+**Input (after applying skill):**
+```
+Write a Flutter button that shows a loading spinner while its async action runs.
+```
+
+**Output:**
+```dart
+class AsyncButton extends StatefulWidget {
+  const AsyncButton({super.key, required this.label, required this.onPressed});
+  final String label;
+  final Future<void> Function() onPressed;
+
+  @override
+  State<AsyncButton> createState() => _AsyncButtonState();
+}
+
+class _AsyncButtonState extends State<AsyncButton> {
+  bool _loading = false;
+
+  Future<void> _handlePress() async {
+    setState(() => _loading = true);
+    try {
+      await widget.onPressed();
+    } finally {
+      if (mounted) setState(() => _loading = false);
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return FilledButton(
+      onPressed: _loading ? null : _handlePress,
+      child: _loading
+          ? const SizedBox(
+              width: 18, height: 18,
+              child: CircularProgressIndicator(strokeWidth: 2),
+            )
+          : Text(widget.label),
+    );
+  }
+}
+```
+
+---
+
+## Composition Example
+
+```
+Prepend this skill to any Flutter code generation request. Example:
+
+"[paste skill prompt]
+
+Now write a widget that shows a paginated list of products with pull-to-refresh."
+```
+
+---
+
+## Notes
+
+- Material 3 is the default from Flutter 3.16. Use `colorScheme` properties, not deprecated `primaryColor`, `backgroundColor`, etc.
+- `withOpacity()` is deprecated in Dart 3.3+ — use `withValues(alpha: ...)` or the `Color.fromRGBO` constructor for new code.

package/skills/gaming/blueprint-to-cpp.md

@@ -0,0 +1,51 @@
+# Skill — /blueprint-to-cpp
+
+**Platform:** Unreal Engine
+**Slash Command:** `/blueprint-to-cpp`
+**Composable With:** agents/gaming/unreal/agent.md
+
+---
+
+## Purpose
+
+Converts Unreal Engine Blueprint logic to performant, idiomatic C++ with full explanation of why each node maps to each C++ construct.
+
+---
+
+## Skill Prompt
+
+```
+Migrate the provided Unreal Blueprint logic to C++:
+
+MIGRATION RULES:
+1. Identify Blueprint patterns that must move to C++ first:
+   - Logic called in Tick (every frame) → C++ mandatory.
+   - Math-heavy calculations (vector ops, lerps in loops) → C++ mandatory.
+   - Logic called > 10 times per second → strong candidate for C++.
+   - Event dispatchers with many subscribers → C++ delegates.
+   - Pure functions used in many places → static C++ utility function.
+
+2. Blueprint node → C++ mapping:
+   - Get Player Character → APlayerController::GetPawn() or Cast<>
+   - Branch → if/else or ternary
+   - For Each Loop → for (const auto& Item : Collection)
+   - Cast To → Cast<TargetType>(Object) with null check
+   - Delay → FTimerHandle + GetWorldTimerManager().SetTimer()
+   - Timeline → UCurveFloat + FTimeline
+   - Print String → UE_LOG(LogTemp, Log, TEXT("...")) — remove before ship
+   - Get All Actors Of Class → GetWorld()->GetAllActorsOfClass() — cache in BeginPlay
+   - Spawn Actor → GetWorld()->SpawnActor<AMyActor>(Class, Transform)
+   - Set Timer by Event → GetWorldTimerManager().SetTimer()
+
+3. UPROPERTY annotations for Blueprint exposure:
+   - BlueprintReadWrite → editable in BP and C++
+   - BlueprintReadOnly → read in BP, set in C++
+   - EditAnywhere, Category = "Config" → exposed in Details panel
+
+4. Output format per migrated function:
+   - Header declaration (.h)
+   - Implementation (.cpp)
+   - Explanation of why this moved to C++
+
+Show the Blueprint pseudocode description alongside the C++ implementation.
+```

package/skills/gaming/game-perf.md

@@ -0,0 +1,54 @@
+# Skill — /game-perf
+
+**Platform:** Unity / Unreal
+**Slash Command:** `/game-perf`
+**Composable With:** agents/gaming/forge/agent.md, agents/gaming/unreal/agent.md
+
+---
+
+## Purpose
+
+Frame budget audit for game scenes. Identifies draw call sources, GC allocation hotspots, physics overhead, and shader complexity. Produces a prioritized optimization plan.
+
+---
+
+## Skill Prompt
+
+```
+Audit the provided game code or scene description for frame budget issues:
+
+FRAME BUDGET REFERENCE:
+- Mobile 60fps: 16.67ms total per frame
+- CPU budget: ~8ms for game logic + physics
+- GPU budget: ~6ms for rendering
+- Rendering budget per call: 0.01–0.1ms on mobile
+
+DRAW CALL ANALYSIS:
+- Count unique materials (each unique material = potential draw call break).
+- Dynamic vs static batching eligibility:
+  Static: non-moving objects with same material → enable static batching.
+  Dynamic: moving objects < 900 vertices, same material → Unity handles automatically.
+- GPU Instancing: many identical meshes (trees, grass, enemies) → enable GPU Instancing on material.
+- Atlas textures: multiple small textures → combine into texture atlas to reduce draw calls.
+
+GC ALLOCATION AUDIT (Unity C#):
+- foreach on List<T>: use for loop (foreach boxes the enumerator on older Unity versions).
+- String operations in Update: build strings in Start or cache with StringBuilder.
+- new MyStruct() in hot path: use object pools (ObjectPool<T> in Unity 2021+).
+- LINQ in Update: pre-compute and cache results.
+- GetComponent in Update: cache in Awake.
+
+PHYSICS OPTIMIZATION:
+- Layer collision matrix: disable collision between layers that never interact.
+- Rigidbody Sleep: set rigidbodies to sleep when idle (Rigidbody.IsSleeping()).
+- Collider complexity: use primitive colliders (Box, Sphere, Capsule) over MeshCollider.
+- FixedUpdate rate: default 0.02 (50fps). Increase for smoother physics; decrease for performance.
+
+RENDERING OPTIMIZATION:
+- Shadow casters: disable shadows on small/distant objects.
+- LOD groups: add LODGroup to complex meshes.
+- Occlusion culling: bake occlusion for enclosed spaces.
+- Shader complexity: mobile shaders should be < 30 instructions per pixel.
+
+Output a prioritized list with estimated frame time saved per optimization.
+```

package/skills/gaming/shader-gen.md

@@ -0,0 +1,44 @@
+# Skill — /shader-gen
+
+**Platform:** Unity (HLSL / ShaderLab) / Unreal (HLSL)
+**Slash Command:** `/shader-gen`
+**Composable With:** agents/gaming/forge/agent.md, agents/gaming/unreal/agent.md
+
+---
+
+## Purpose
+
+Generates HLSL/ShaderLab shader code from a plain English visual description. Covers URP, HDRP, and Built-in pipeline for Unity; material expressions for Unreal.
+
+---
+
+## Skill Prompt
+
+```
+Generate shader code for the described visual effect:
+
+INPUT FORMAT:
+PLATFORM: <Unity-URP | Unity-HDRP | Unity-BuiltIn | Unreal>
+EFFECT: <plain English description of the visual effect>
+PERFORMANCE_TARGET: <Mobile | PC | Console>
+PROPERTIES_NEEDED: <list any tweakable properties — colors, speeds, intensities>
+
+GENERATION RULES:
+1. Minimize instruction count for mobile targets.
+2. Avoid dynamic branching (if/else in shader) on mobile — use step(), lerp(), saturate().
+3. Include fallback for mobile limitations (no geometry shaders on OpenGL ES 2.0).
+4. Expose meaningful properties to the Material Inspector via Properties block.
+5. Add ShaderLab properties with [HDR] for emissive colors, [Toggle] for booleans.
+
+EFFECT PATTERNS:
+- Dissolve effect: use noise texture + cutoff threshold + clip().
+- Hologram: scanline UV offset + rim lighting + fresnel term.
+- Water ripple: sin-based UV distortion + normal map.
+- Outline: render back faces scaled along normal in separate pass.
+- Glow/bloom: emissive color with HDR intensity > 1.
+- Toon/cel shading: step() on diffuse lighting term.
+- Fresnel rim light: pow(1 - dot(viewDir, normal), power) * rimColor.
+
+Output complete ShaderLab (.shader) file or HLSL material function.
+Note instruction count estimate and mobile compatibility.
+```