@cubis/foundry 0.3.31 → 0.3.33

package/workflows/workflows/agent-environment-setup/platforms/cursor/skills/postman/gorouter-restoration/POWER.md

@@ -0,0 +1,227 @@
+---
+name: "gorouter-restoration"
+displayName: "GoRouter & State Restoration"
+description: "Implement GoRouter patterns: guards, deep links, tab preservation, state restoration, and safe redirects"
+keywords:
+  [
+    "gorouter",
+    "routing",
+    "navigation",
+    "guards",
+    "deep links",
+    "state restoration",
+    "tab navigation",
+  ]
+---
+
+# GoRouter & State Restoration
+
+## Overview
+
+This power helps you implement robust routing with GoRouter, including authentication guards, deep link handling, tab state preservation, and Flutter state restoration.
+
+## When to Use
+
+- Adding new routes to the app
+- Implementing authentication guards
+- Setting up deep link handling
+- Preserving tab/scroll state
+- Debugging navigation issues
+- Implementing state restoration
+
+## Quick Reference
+
+### Route Definition
+
+```dart
+// ✅ Define routes with constants
+class AppRoutes {
+  static const login = '/login';
+  static const home = '/home';
+  static const leaveDetail = '/leave/:id';
+  static const profile = '/profile';
+}
+
+// ✅ Use in router config
+GoRoute(
+  path: AppRoutes.leaveDetail,
+  name: 'leaveDetail',
+  builder: (context, state) {
+    final id = state.pathParameters['id']!;
+    return LeaveDetailView(leaveId: id);
+  },
+)
+```
+
+### Authentication Guard
+
+```dart
+// ✅ Guard implementation
+class AuthGuard {
+  static String? redirect(BuildContext context, GoRouterState state) {
+    final isAuthenticated = /* check auth provider */;
+    final isLoginRoute = state.matchedLocation == AppRoutes.login;
+    
+    // Prevent redirect loop
+    if (!isAuthenticated && !isLoginRoute) {
+      return AppRoutes.login;
+    }
+    
+    // Already on login, no redirect needed
+    if (isAuthenticated && isLoginRoute) {
+      return AppRoutes.home;
+    }
+    
+    return null; // No redirect
+  }
+}
+```
+
+### Tab Preservation
+
+```dart
+// ✅ Use StatefulShellRoute for bottom tabs
+StatefulShellRoute.indexedStack(
+  builder: (context, state, navigationShell) {
+    return ScaffoldWithNavBar(navigationShell: navigationShell);
+  },
+  branches: [
+    StatefulShellBranch(
+      routes: [
+        GoRoute(path: '/home', builder: (context, state) => HomeView()),
+      ],
+    ),
+    StatefulShellBranch(
+      routes: [
+        GoRoute(path: '/profile', builder: (context, state) => ProfileView()),
+      ],
+    ),
+  ],
+)
+```
+
+### Deep Link Handling
+
+```dart
+// ✅ Handle deep links with guards
+GoRoute(
+  path: '/leave/:id',
+  redirect: (context, state) {
+    // Check auth before allowing deep link
+    return AuthGuard.redirect(context, state);
+  },
+  builder: (context, state) {
+    final id = state.pathParameters['id']!;
+    return LeaveDetailView(leaveId: id);
+  },
+)
+```
+
+## Routing Checklist
+
+### Route Definition
+- [ ] Routes defined in AppRoutes constants
+- [ ] Route names are descriptive
+- [ ] Path parameters use typed extraction
+- [ ] Query parameters handled correctly
+
+### Guards
+- [ ] Authentication guard prevents unauthorized access
+- [ ] Role-based guards check permissions
+- [ ] Maintenance mode guard redirects when needed
+- [ ] No redirect loops (check current location)
+
+### Deep Links
+- [ ] All routes accessible via deep links
+- [ ] Guards protect deep-linked routes
+- [ ] Invalid parameters handled gracefully
+- [ ] Deep links tested on iOS and Android
+
+### State Preservation
+- [ ] Bottom tab state preserved
+- [ ] Scroll position preserved where needed
+- [ ] Form drafts preserved (if required)
+- [ ] RestorationScope configured
+
+### Navigation Safety
+- [ ] Back button behavior is correct
+- [ ] Pop until works correctly
+- [ ] Navigation after logout clears stack
+- [ ] No navigation during async operations
+
+## Common Patterns
+
+### Redirect Loop Prevention
+
+```dart
+// ❌ Bad - causes redirect loop
+if (!isAuthenticated) {
+  return AppRoutes.login; // Always redirects!
+}
+
+// ✅ Good - checks current location
+if (!isAuthenticated && state.matchedLocation != AppRoutes.login) {
+  return AppRoutes.login;
+}
+```
+
+### Passing Data
+
+```dart
+// ❌ Bad - passing large objects
+context.push('/detail', extra: largeObject);
+
+// ✅ Good - pass ID, fetch in destination
+context.push('/detail/$id');
+```
+
+### State Restoration
+
+```dart
+// ✅ Enable restoration
+MaterialApp.router(
+  restorationScopeId: 'app',
+  routerConfig: router,
+)
+
+// ✅ Use restoration mixin in stateful widgets
+class MyView extends StatefulWidget {
+  @override
+  State<MyView> createState() => _MyViewState();
+}
+
+class _MyViewState extends State<MyView> with RestorationMixin {
+  @override
+  String? get restorationId => 'my_view';
+  
+  final _scrollController = RestorableScrollController();
+  
+  @override
+  void restoreState(RestorationBucket? oldBucket, bool initialRestore) {
+    registerForRestoration(_scrollController, 'scroll');
+  }
+}
+```
+
+## Output Format
+
+When implementing routing:
+
+1. **Route Plan** (paths, names, params)
+2. **Guard Plan** (what checks where)
+3. **Restoration Plan** (what state is preserved)
+4. **Edge Cases** (deep link, logout, maintenance, back nav)
+5. **Code Snippets** (relevant blocks)
+6. **Tests** (router tests / widget tests)
+
+## Steering Files
+
+- `guard_patterns.md` - Guard implementation patterns
+- `tab_preservation.md` - Tab state preservation
+- `deep_link_handling.md` - Deep link best practices
+
+## Templates
+
+- `guard_redirect` - Guard redirect template
+- `stateful_shell_skeleton` - Tab navigation template
+

package/workflows/workflows/agent-environment-setup/platforms/cursor/skills/postman/gorouter-restoration/SKILL.md

@@ -0,0 +1,217 @@
+---
+name: "gorouter-restoration"
+description: "Implement GoRouter patterns: guards, deep links, tab preservation, state restoration, and safe redirects"
+---
+
+
+# GoRouter & State Restoration
+
+## Overview
+
+This power helps you implement robust routing with GoRouter, including authentication guards, deep link handling, tab state preservation, and Flutter state restoration.
+
+## When to Use
+
+- Adding new routes to the app
+- Implementing authentication guards
+- Setting up deep link handling
+- Preserving tab/scroll state
+- Debugging navigation issues
+- Implementing state restoration
+
+## Quick Reference
+
+### Route Definition
+
+```dart
+// ✅ Define routes with constants
+class AppRoutes {
+  static const login = '/login';
+  static const home = '/home';
+  static const leaveDetail = '/leave/:id';
+  static const profile = '/profile';
+}
+
+// ✅ Use in router config
+GoRoute(
+  path: AppRoutes.leaveDetail,
+  name: 'leaveDetail',
+  builder: (context, state) {
+    final id = state.pathParameters['id']!;
+    return LeaveDetailView(leaveId: id);
+  },
+)
+```
+
+### Authentication Guard
+
+```dart
+// ✅ Guard implementation
+class AuthGuard {
+  static String? redirect(BuildContext context, GoRouterState state) {
+    final isAuthenticated = /* check auth provider */;
+    final isLoginRoute = state.matchedLocation == AppRoutes.login;
+    
+    // Prevent redirect loop
+    if (!isAuthenticated && !isLoginRoute) {
+      return AppRoutes.login;
+    }
+    
+    // Already on login, no redirect needed
+    if (isAuthenticated && isLoginRoute) {
+      return AppRoutes.home;
+    }
+    
+    return null; // No redirect
+  }
+}
+```
+
+### Tab Preservation
+
+```dart
+// ✅ Use StatefulShellRoute for bottom tabs
+StatefulShellRoute.indexedStack(
+  builder: (context, state, navigationShell) {
+    return ScaffoldWithNavBar(navigationShell: navigationShell);
+  },
+  branches: [
+    StatefulShellBranch(
+      routes: [
+        GoRoute(path: '/home', builder: (context, state) => HomeView()),
+      ],
+    ),
+    StatefulShellBranch(
+      routes: [
+        GoRoute(path: '/profile', builder: (context, state) => ProfileView()),
+      ],
+    ),
+  ],
+)
+```
+
+### Deep Link Handling
+
+```dart
+// ✅ Handle deep links with guards
+GoRoute(
+  path: '/leave/:id',
+  redirect: (context, state) {
+    // Check auth before allowing deep link
+    return AuthGuard.redirect(context, state);
+  },
+  builder: (context, state) {
+    final id = state.pathParameters['id']!;
+    return LeaveDetailView(leaveId: id);
+  },
+)
+```
+
+## Routing Checklist
+
+### Route Definition
+- [ ] Routes defined in AppRoutes constants
+- [ ] Route names are descriptive
+- [ ] Path parameters use typed extraction
+- [ ] Query parameters handled correctly
+
+### Guards
+- [ ] Authentication guard prevents unauthorized access
+- [ ] Role-based guards check permissions
+- [ ] Maintenance mode guard redirects when needed
+- [ ] No redirect loops (check current location)
+
+### Deep Links
+- [ ] All routes accessible via deep links
+- [ ] Guards protect deep-linked routes
+- [ ] Invalid parameters handled gracefully
+- [ ] Deep links tested on iOS and Android
+
+### State Preservation
+- [ ] Bottom tab state preserved
+- [ ] Scroll position preserved where needed
+- [ ] Form drafts preserved (if required)
+- [ ] RestorationScope configured
+
+### Navigation Safety
+- [ ] Back button behavior is correct
+- [ ] Pop until works correctly
+- [ ] Navigation after logout clears stack
+- [ ] No navigation during async operations
+
+## Common Patterns
+
+### Redirect Loop Prevention
+
+```dart
+// ❌ Bad - causes redirect loop
+if (!isAuthenticated) {
+  return AppRoutes.login; // Always redirects!
+}
+
+// ✅ Good - checks current location
+if (!isAuthenticated && state.matchedLocation != AppRoutes.login) {
+  return AppRoutes.login;
+}
+```
+
+### Passing Data
+
+```dart
+// ❌ Bad - passing large objects
+context.push('/detail', extra: largeObject);
+
+// ✅ Good - pass ID, fetch in destination
+context.push('/detail/$id');
+```
+
+### State Restoration
+
+```dart
+// ✅ Enable restoration
+MaterialApp.router(
+  restorationScopeId: 'app',
+  routerConfig: router,
+)
+
+// ✅ Use restoration mixin in stateful widgets
+class MyView extends StatefulWidget {
+  @override
+  State<MyView> createState() => _MyViewState();
+}
+
+class _MyViewState extends State<MyView> with RestorationMixin {
+  @override
+  String? get restorationId => 'my_view';
+  
+  final _scrollController = RestorableScrollController();
+  
+  @override
+  void restoreState(RestorationBucket? oldBucket, bool initialRestore) {
+    registerForRestoration(_scrollController, 'scroll');
+  }
+}
+```
+
+## Output Format
+
+When implementing routing:
+
+1. **Route Plan** (paths, names, params)
+2. **Guard Plan** (what checks where)
+3. **Restoration Plan** (what state is preserved)
+4. **Edge Cases** (deep link, logout, maintenance, back nav)
+5. **Code Snippets** (relevant blocks)
+6. **Tests** (router tests / widget tests)
+
+## Steering Files
+
+- `guard_patterns.md` - Guard implementation patterns
+- `tab_preservation.md` - Tab state preservation
+- `deep_link_handling.md` - Deep link best practices
+
+## Templates
+
+- `guard_redirect` - Guard redirect template
+- `stateful_shell_skeleton` - Tab navigation template
+

package/workflows/workflows/agent-environment-setup/platforms/cursor/skills/postman/gorouter-restoration/references/guard_patterns.md

@@ -0,0 +1,14 @@
+# Guard patterns (safe redirects)
+
+Rules:
+- No async side effects in redirect.
+- Read session state from providers.
+- Avoid redirect loops.
+
+Pseudo rules:
+- If not logged in and route requires auth -> redirect to login
+- If logged in and route is login/activation -> redirect to home
+- If maintenance mode -> redirect to maintenance screen, except allowlist routes
+
+Also:
+- When redirecting to login, include an optional `from=` query so you can return after login.

package/workflows/workflows/agent-environment-setup/platforms/cursor/skills/postman/gorouter-restoration/references/tab_preservation.md

@@ -0,0 +1,12 @@
+# Tab preservation & state restoration
+
+Recommended:
+- `StatefulShellRoute.indexedStack` to preserve state per branch.
+- Each branch uses its own navigator key.
+- Do not rebuild the entire shell on tab switch.
+
+What to preserve:
+- current tab index
+- each tab stack
+- scroll positions (ListView/ScrollController) if necessary
+- form drafts using local state or dedicated draft providers (ephemeral)

package/workflows/workflows/agent-environment-setup/platforms/cursor/skills/postman/gorouter-restoration/templates/guard_redirect.md

@@ -0,0 +1,30 @@
+```
+// templates/guard_redirect.tmpl
+//
+// Safe redirect function sketch (keep it pure).
+
+String? redirectLogic({
+  required bool isLoggedIn,
+  required bool isMaintenance,
+  required String location,
+}) {
+  final isOnLogin = location.startsWith('/login');
+  final isOnSplash = location == '/';
+  final isProtected = location.startsWith('/home') || location.startsWith('/attendance');
+
+  if (isMaintenance && !location.startsWith('/maintenance')) {
+    return '/maintenance';
+  }
+
+  if (!isLoggedIn && isProtected && !isOnLogin) {
+    return '/login?from=${Uri.encodeComponent(location)}';
+  }
+
+  if (isLoggedIn && isOnLogin) {
+    return '/home';
+  }
+
+  // allow
+  return null;
+}
+```

package/workflows/workflows/agent-environment-setup/platforms/cursor/skills/postman/gorouter-restoration/templates/stateful_shell_skeleton.md

@@ -0,0 +1,40 @@
+```
+// templates/stateful_shell_skeleton.tmpl
+//
+// Skeleton for tab preservation using StatefulShellRoute.indexedStack.
+
+final _rootKey = GlobalKey<NavigatorState>();
+final _homeKey = GlobalKey<NavigatorState>();
+final _leaveKey = GlobalKey<NavigatorState>();
+final _taskKey = GlobalKey<NavigatorState>();
+final _profileKey = GlobalKey<NavigatorState>();
+
+final router = GoRouter(
+  navigatorKey: _rootKey,
+  routes: [
+    StatefulShellRoute.indexedStack(
+      branches: [
+        StatefulShellBranch(
+          navigatorKey: _homeKey,
+          routes: [GoRoute(path: '/home', builder: (c, s) => const HomeView())],
+        ),
+        StatefulShellBranch(
+          navigatorKey: _leaveKey,
+          routes: [GoRoute(path: '/leave', builder: (c, s) => const LeaveView())],
+        ),
+        StatefulShellBranch(
+          navigatorKey: _taskKey,
+          routes: [GoRoute(path: '/task', builder: (c, s) => const TaskView())],
+        ),
+        StatefulShellBranch(
+          navigatorKey: _profileKey,
+          routes: [GoRoute(path: '/profile', builder: (c, s) => const ProfileView())],
+        ),
+      ],
+      builder: (context, state, navigationShell) {
+        return AppShell(navigationShell: navigationShell);
+      },
+    ),
+  ],
+);
+```

package/workflows/workflows/agent-environment-setup/platforms/cursor/skills/postman/mcp.json

@@ -0,0 +1,11 @@
+{
+  "mcpServers": {
+    "postman": {
+      "url":"https://mcp.postman.com/minimal",
+      "headers": {
+        "Authorization": "Bearer ${POSTMAN_API_KEY}"
+      }
+    }
+  },
+  "disabled": false
+}

package/workflows/workflows/agent-environment-setup/platforms/cursor/skills/postman/microservices-architect/POWER.md

@@ -0,0 +1,109 @@
+---
+name: microservices-architect
+displayName: Microservices Architect
+description:
+  Use when designing distributed systems, decomposing monoliths, or implementing
+  microservices patterns. Invoke for service boundaries, DDD, saga patterns, event
+  sourcing, service mesh, distributed tracing.
+keywords:
+  - microservices
+  - service mesh
+  - distributed systems
+  - service boundaries
+  - domain-driven design
+  - event sourcing
+  - CQRS
+  - saga pattern
+  - Kubernetes microservices
+  - Istio
+  - distributed tracing
+author: OneUp
+---
+
+# Microservices Architect
+
+## Overview
+
+Senior distributed systems architect specializing in cloud-native microservices architectures, resilience patterns, and operational excellence.
+
+## Role Definition
+
+You are a senior microservices architect with 15+ years of experience designing distributed systems. You specialize in service decomposition, domain-driven design, resilience patterns, service mesh technologies, and cloud-native architectures. You design systems that scale, self-heal, and enable autonomous teams.
+
+## When to Use This Skill
+
+- Decomposing monoliths into microservices
+- Defining service boundaries and bounded contexts
+- Designing inter-service communication patterns
+- Implementing resilience patterns (circuit breakers, retries, bulkheads)
+- Setting up service mesh (Istio, Linkerd)
+- Designing event-driven architectures
+- Implementing distributed transactions (Saga, CQRS)
+- Establishing observability (tracing, metrics, logging)
+
+## Core Workflow
+
+1. **Domain Analysis** - Apply DDD to identify bounded contexts and service boundaries
+2. **Communication Design** - Choose sync/async patterns, protocols (REST, gRPC, events)
+3. **Data Strategy** - Database per service, event sourcing, eventual consistency
+4. **Resilience** - Circuit breakers, retries, timeouts, bulkheads, fallbacks
+5. **Observability** - Distributed tracing, correlation IDs, centralized logging
+6. **Deployment** - Container orchestration, service mesh, progressive delivery
+
+## Available Steering Files
+
+Load detailed guidance on-demand:
+
+| Topic               | Reference                   | Load When                                          |
+| ------------------- | --------------------------- | -------------------------------------------------- |
+| Service Boundaries  | `references/decomposition.md` | Monolith decomposition, bounded contexts, DDD      |
+| Communication       | `references/communication.md` | REST vs gRPC, async messaging, event-driven        |
+| Resilience Patterns | `references/patterns.md`      | Circuit breakers, saga, bulkhead, retry strategies |
+| Data Management     | `references/data.md`          | Database per service, event sourcing, CQRS         |
+| Observability       | `references/observability.md` | Distributed tracing, correlation IDs, metrics      |
+
+## Constraints
+
+### MUST DO
+
+- Apply domain-driven design for service boundaries
+- Use database per service pattern
+- Implement circuit breakers for external calls
+- Add correlation IDs to all requests
+- Use async communication for cross-aggregate operations
+- Design for failure and graceful degradation
+- Implement health checks and readiness probes
+- Use API versioning strategies
+
+### MUST NOT DO
+
+- Create distributed monoliths
+- Share databases between services
+- Use synchronous calls for long-running operations
+- Skip distributed tracing implementation
+- Ignore network latency and partial failures
+- Create chatty service interfaces
+- Store shared state without proper patterns
+- Deploy without observability
+
+## Output Templates
+
+When designing microservices architecture, provide:
+
+1. Service boundary diagram with bounded contexts
+2. Communication patterns (sync/async, protocols)
+3. Data ownership and consistency model
+4. Resilience patterns for each integration point
+5. Deployment and infrastructure requirements
+
+## Knowledge Reference
+
+Domain-driven design, bounded contexts, event storming, REST/gRPC, message queues (Kafka, RabbitMQ), service mesh (Istio, Linkerd), Kubernetes, circuit breakers, saga patterns, event sourcing, CQRS, distributed tracing (Jaeger, Zipkin), API gateways, eventual consistency, CAP theorem
+
+## Related Powers
+
+- **DevOps Engineer** - Container orchestration and CI/CD pipelines
+- **Kubernetes Specialist** - Advanced K8s patterns and operators
+- **GraphQL Architect** - Federation for distributed schemas
+- **Architecture Designer** - High-level system design
+- **Monitoring Expert** - Observability implementation