@ruyfranca/myskills 1.0.28 → 1.0.30

package/.agent/skills/golang-pro/SKILL.md

@@ -0,0 +1,121 @@
+---
+name: golang-pro
+description: Master Go 1.21+ with modern patterns, advanced concurrency, performance optimization, and production-ready microservices.
+risk: unknown
+source: community
+date_added: "2026-02-27"
+---
+
+# Go Pro
+
+You are a Go expert specializing in modern Go 1.21+ development with advanced concurrency patterns, performance optimization, and production-ready system design.
+
+## Use this skill when
+
+- Building Go services, CLIs, or microservices
+- Designing concurrency patterns and performance optimizations
+- Reviewing Go architecture and production readiness
+
+## Do not use this skill when
+
+- You need another language or runtime
+- You only need basic Go syntax explanations
+- You cannot change Go tooling or build configuration
+
+## Instructions
+
+1. Confirm Go version, tooling, and runtime constraints.
+2. Choose concurrency and architecture patterns.
+3. Implement with testing and profiling.
+4. Optimize for latency, memory, and reliability.
+
+## Key Capabilities
+
+### Concurrency & Parallelism
+
+```go
+// Worker pool pattern
+func workerPool(ctx context.Context, jobs <-chan Job, numWorkers int) <-chan Result {
+    results := make(chan Result, numWorkers)
+    var wg sync.WaitGroup
+    
+    for i := 0; i < numWorkers; i++ {
+        wg.Add(1)
+        go func() {
+            defer wg.Done()
+            for job := range jobs {
+                select {
+                case results <- processJob(ctx, job):
+                case <-ctx.Done():
+                    return
+                }
+            }
+        }()
+    }
+    
+    go func() {
+        wg.Wait()
+        close(results)
+    }()
+    
+    return results
+}
+```
+
+### Error Handling
+
+```go
+// Wrap errors with context
+if err := store.Save(user); err != nil {
+    return fmt.Errorf("saving user %s: %w", user.ID, err)
+}
+
+// Sentinel errors
+var ErrNotFound = errors.New("not found")
+
+// Check wrapped errors
+if errors.Is(err, ErrNotFound) {
+    // handle not found
+}
+```
+
+### Testing
+
+```go
+func TestCalculate(t *testing.T) {
+    cases := []struct {
+        name  string
+        input int
+        want  int
+    }{
+        {"positive", 5, 25},
+        {"zero", 0, 0},
+        {"negative", -3, 9},
+    }
+    
+    for _, tc := range cases {
+        t.Run(tc.name, func(t *testing.T) {
+            got := Calculate(tc.input)
+            if got != tc.want {
+                t.Errorf("Calculate(%d) = %d, want %d", tc.input, got, tc.want)
+            }
+        })
+    }
+}
+```
+
+## Modern Go Features (1.21+)
+
+- Structured logging with `slog` (built-in)
+- Improved type inference for generics
+- `slices` and `maps` packages for common operations
+- `min`, `max`, `clear` built-in functions
+- `errors.Join` for combining errors
+
+## Best Practices
+
+- Prefer composition over inheritance (embed interfaces)
+- Accept interfaces, return structs
+- Use context for cancellation and deadlines
+- Profile before optimizing (pprof)
+- Use `golangci-lint` with strict config in CI

package/.agent/skills/kotlin-coroutines-expert/SKILL.md

@@ -0,0 +1,99 @@
+---
+name: kotlin-coroutines-expert
+description: "Expert patterns for Kotlin Coroutines and Flow, covering structured concurrency, error handling, and testing."
+risk: safe
+source: community
+date_added: "2026-02-27"
+---
+
+# Kotlin Coroutines Expert
+
+## Overview
+
+A guide to mastering asynchronous programming with Kotlin Coroutines. Covers advanced topics like structured concurrency, `Flow` transformations, exception handling, and testing strategies.
+
+## When to Use This Skill
+
+- Use when implementing asynchronous operations in Kotlin.
+- Use when designing reactive data streams with `Flow`.
+- Use when debugging coroutine cancellations or exceptions.
+- Use when writing unit tests for suspending functions or Flows.
+
+## Step-by-Step Guide
+
+### 1. Structured Concurrency
+
+Always launch coroutines within a defined `CoroutineScope`. Use `coroutineScope` or `supervisorScope` to group concurrent tasks.
+
+```kotlin
+suspend fun loadDashboardData(): DashboardData = coroutineScope {
+    val userDeferred = async { userRepo.getUser() }
+    val settingsDeferred = async { settingsRepo.getSettings() }
+    
+    DashboardData(
+        user = userDeferred.await(),
+        settings = settingsDeferred.await()
+    )
+}
+```
+
+### 2. Exception Handling
+
+Use `CoroutineExceptionHandler` for top-level scopes, but rely on `try-catch` within suspending functions for granular control.
+
+```kotlin
+val handler = CoroutineExceptionHandler { _, exception ->
+    println("Caught $exception")
+}
+
+viewModelScope.launch(handler) {
+    try {
+        riskyOperation()
+    } catch (e: IOException) {
+        // Handle network error specifically
+    }
+}
+```
+
+### 3. Reactive Streams with Flow
+
+Use `StateFlow` for state that needs to be retained, and `SharedFlow` for events.
+
+```kotlin
+// Cold Flow (Lazy)
+val searchResults: Flow<List<Item>> = searchQuery
+    .debounce(300)
+    .flatMapLatest { query -> searchRepo.search(query) }
+    .flowOn(Dispatchers.IO)
+
+// Hot Flow (State)
+val uiState: StateFlow<UiState> = _uiState.asStateFlow()
+```
+
+### 4. Parallel Execution with Error Handling
+
+```kotlin
+suspend fun fetchDataWithErrorHandling() = supervisorScope {
+    val task1 = async { 
+        try { api.fetchA() } catch (e: Exception) { null } 
+    }
+    val task2 = async { api.fetchB() }
+    
+    // If task2 fails, task1 is NOT cancelled because of supervisorScope
+    val result1 = task1.await()
+    val result2 = task2.await() // May throw
+}
+```
+
+## Best Practices
+
+- ✅ **Do:** Use `Dispatchers.IO` for blocking I/O operations.
+- ✅ **Do:** Cancel scopes when they are no longer needed (e.g., `ViewModel.onCleared`).
+- ✅ **Do:** Use `TestScope` and `runTest` for unit testing coroutines.
+- ❌ **Don't:** Use `GlobalScope`. It breaks structured concurrency and can lead to leaks.
+- ❌ **Don't:** Catch `CancellationException` unless you rethrow it.
+
+## Troubleshooting
+
+**Problem:** Coroutine test hangs or fails unpredictably.
+**Solution:** Ensure you are using `runTest` and injecting `TestDispatcher` into your classes so you can control virtual time.

package/.agent/skills/modern-javascript-patterns/SKILL.md

@@ -0,0 +1,131 @@
+---
+name: modern-javascript-patterns
+description: "Master ES6+ features including async/await, destructuring, spread operators, arrow functions, promises, modules, iterators, generators, and functional programming patterns for writing clean, efficient code."
+risk: unknown
+source: community
+date_added: "2026-02-27"
+---
+
+# Modern JavaScript Patterns
+
+Comprehensive guide for mastering modern JavaScript (ES6+) features, functional programming patterns, and best practices for writing clean, maintainable, and performant code.
+
+## Use this skill when
+
+- Refactoring legacy JavaScript to modern syntax
+- Implementing functional programming patterns
+- Optimizing JavaScript performance
+- Writing maintainable and readable code
+- Working with asynchronous operations
+- Building modern web applications
+- Migrating from callbacks to Promises/async-await
+- Implementing data transformation pipelines
+
+## Do not use this skill when
+
+- The task is unrelated to modern javascript patterns
+- You need a different domain or tool outside this scope
+
+## Instructions
+
+- Clarify goals, constraints, and required inputs.
+- Apply relevant best practices and validate outcomes.
+- Provide actionable steps and verification.
+
+## Core Patterns
+
+### 1. Async/Await
+
+```javascript
+// ✅ Modern async patterns
+const fetchData = async (url) => {
+  const response = await fetch(url);
+  if (!response.ok) throw new Error(`HTTP ${response.status}`);
+  return response.json();
+};
+
+// Parallel execution
+const [users, posts] = await Promise.all([fetchUsers(), fetchPosts()]);
+
+// Error handling
+const result = await fetchData(url).catch(err => ({ error: err.message }));
+```
+
+### 2. Destructuring & Spread
+
+```javascript
+// Object destructuring with defaults
+const { name = 'Anonymous', role = 'user', ...rest } = user;
+
+// Array destructuring
+const [first, second, ...remaining] = items;
+
+// Function parameters
+const greet = ({ name, greeting = 'Hello' }) => `${greeting}, ${name}!`;
+```
+
+### 3. Functional Patterns
+
+```javascript
+// Immutable transformations
+const updated = items.map(item => item.id === id ? { ...item, done: true } : item);
+const active = items.filter(item => !item.done);
+const total = items.reduce((sum, item) => sum + item.price, 0);
+
+// Composition
+const pipe = (...fns) => x => fns.reduce((v, f) => f(v), x);
+const process = pipe(validate, normalize, format);
+```
+
+### 4. Modules (ESM)
+
+```javascript
+// Named exports
+export const add = (a, b) => a + b;
+export const multiply = (a, b) => a * b;
+
+// Dynamic import (lazy loading)
+const module = await import('./heavy-module.js');
+```
+
+### 5. Generators & Iterators
+
+```javascript
+function* range(start, end, step = 1) {
+  for (let i = start; i < end; i += step) yield i;
+}
+
+// Paginated data fetching
+async function* paginate(fetchPage) {
+  let page = 1;
+  while (true) {
+    const data = await fetchPage(page++);
+    if (!data.length) break;
+    yield* data;
+  }
+}
+```
+
+### 6. Proxy & Reflect
+
+```javascript
+const handler = {
+  get(target, key) {
+    return key in target ? target[key] : `Property ${key} not found`;
+  },
+  set(target, key, value) {
+    if (typeof value !== 'string') throw new TypeError('Value must be string');
+    return Reflect.set(target, key, value);
+  }
+};
+```
+
+## Anti-Patterns
+
+| ❌ Avoid | ✅ Use Instead |
+|---------|--------------|
+| `var` | `const` / `let` |
+| Callback hell | async/await |
+| `arguments` object | Rest parameters |
+| Mutating arrays | map/filter/spread |
+| `eval()` | Template literals |

package/.agent/skills/monorepo-architect/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: monorepo-architect
+description: "Expert in monorepo architecture, build systems, and dependency management at scale. Masters Nx, Turborepo, Bazel, and Lerna for efficient multi-project development."
+risk: unknown
+source: community
+date_added: "2026-02-27"
+---
+
+# Monorepo Architect
+
+Expert in monorepo architecture, build systems, and dependency management at scale. Masters Nx, Turborepo, Bazel, and Lerna for efficient multi-project development. Use PROACTIVELY for monorepo setup, build optimization, or scaling development workflows across teams.
+
+## Use this skill when
+
+- Setting up a new monorepo from scratch
+- Migrating from polyrepo to monorepo
+- Optimizing slow CI/CD pipelines
+- Sharing code between multiple applications
+- Managing dependencies across projects
+- Implementing consistent tooling across teams
+
+## Do not use this skill when
+
+- The task is unrelated to monorepo architect
+- You need a different domain or tool outside this scope
+
+## Capabilities
+
+- Monorepo tool selection (Nx, Turborepo, Bazel, Lerna)
+- Workspace configuration and project structure
+- Build caching (local and remote)
+- Dependency graph management
+- Affected/changed detection for CI optimization
+- Code sharing and library extraction
+- Task orchestration and parallelization
+
+## Tool Selection Guide
+
+| Tool | Best For | Key Feature |
+|------|----------|-------------|
+| **Turborepo** | JS/TS projects, simple setup | Remote caching, fast incremental builds |
+| **Nx** | Large teams, enterprise | Dependency graph, affected commands |
+| **Bazel** | Polyglot, Google-scale | Hermetic builds, extreme scalability |
+| **Lerna** | npm package publishing | Versioning/publishing automation |
+
+## Workflow
+
+1. Assess codebase size and team structure
+2. Select appropriate monorepo tooling
+3. Design workspace and project structure
+4. Configure build caching strategy
+5. Set up affected/changed detection
+6. Implement task pipelines
+7. Configure remote caching for CI
+8. Document conventions and workflows
+
+## Turborepo Example
+
+```json
+// turbo.json
+{
+  "$schema": "https://turbo.build/schema.json",
+  "tasks": {
+    "build": {
+      "dependsOn": ["^build"],
+      "outputs": [".next/**", "dist/**"]
+    },
+    "test": {
+      "dependsOn": ["build"],
+      "cache": false
+    },
+    "lint": {
+      "cache": true
+    }
+  },
+  "remoteCache": {
+    "enabled": true
+  }
+}
+```
+
+## Best Practices
+
+- Start with clear project boundaries
+- Use consistent naming conventions
+- Implement remote caching early
+- Keep shared libraries focused
+- Use tags for dependency constraints
+- Automate dependency updates
+- Document the dependency graph
+- Set up code ownership rules