aigroup-workflow 2.1.1 → 2.2.0

package/skills/cpp-pro/references/templates.md

@@ -1,357 +0,0 @@
-# Template Metaprogramming
-
-## Variadic Templates
-
-```cpp
-#include <iostream>
-#include <utility>
-
-// Fold expressions (C++17)
-template<typename... Args>
-auto sum(Args... args) {
-    return (args + ...);  // Unary right fold
-}
-
-template<typename... Args>
-void print(Args&&... args) {
-    ((std::cout << args << ' '), ...);  // Binary left fold
-    std::cout << '\n';
-}
-
-// Recursive variadic template
-template<typename T>
-void log(T&& value) {
-    std::cout << value << '\n';
-}
-
-template<typename T, typename... Args>
-void log(T&& first, Args&&... rest) {
-    std::cout << first << ", ";
-    log(std::forward<Args>(rest)...);
-}
-
-// Parameter pack expansion
-template<typename... Types>
-struct TypeList {
-    static constexpr size_t size = sizeof...(Types);
-};
-
-template<typename... Args>
-auto make_tuple_advanced(Args&&... args) {
-    return std::tuple<std::decay_t<Args>...>(std::forward<Args>(args)...);
-}
-```
-
-## SFINAE and if constexpr
-
-```cpp
-#include <type_traits>
-
-// SFINAE with std::enable_if (older style)
-template<typename T>
-std::enable_if_t<std::is_integral_v<T>, T>
-double_value(T value) {
-    return value * 2;
-}
-
-template<typename T>
-std::enable_if_t<std::is_floating_point_v<T>, T>
-double_value(T value) {
-    return value * 2.0;
-}
-
-// Modern: if constexpr (C++17)
-template<typename T>
-auto process(T value) {
-    if constexpr (std::is_integral_v<T>) {
-        return value * 2;
-    } else if constexpr (std::is_floating_point_v<T>) {
-        return value * 2.0;
-    } else {
-        return value;
-    }
-}
-
-// Detection idiom
-template<typename T, typename = void>
-struct has_serialize : std::false_type {};
-
-template<typename T>
-struct has_serialize<T, std::void_t<decltype(std::declval<T>().serialize())>>
-    : std::true_type {};
-
-template<typename T>
-constexpr bool has_serialize_v = has_serialize<T>::value;
-
-// Use with if constexpr
-template<typename T>
-void save(const T& obj) {
-    if constexpr (has_serialize_v<T>) {
-        obj.serialize();
-    } else {
-        // Default serialization
-    }
-}
-```
-
-## Type Traits
-
-```cpp
-#include <type_traits>
-
-// Custom type traits
-template<typename T>
-struct remove_all_pointers {
-    using type = T;
-};
-
-template<typename T>
-struct remove_all_pointers<T*> {
-    using type = typename remove_all_pointers<T>::type;
-};
-
-template<typename T>
-using remove_all_pointers_t = typename remove_all_pointers<T>::type;
-
-// Conditional types
-template<bool Condition, typename T, typename F>
-struct conditional_type {
-    using type = T;
-};
-
-template<typename T, typename F>
-struct conditional_type<false, T, F> {
-    using type = F;
-};
-
-// Compile-time type selection
-template<size_t N>
-struct best_integral_type {
-    using type = std::conditional_t<N <= 8, uint8_t,
-                 std::conditional_t<N <= 16, uint16_t,
-                 std::conditional_t<N <= 32, uint32_t, uint64_t>>>;
-};
-
-// Check for member functions
-template<typename T, typename = void>
-struct has_reserve : std::false_type {};
-
-template<typename T>
-struct has_reserve<T, std::void_t<decltype(std::declval<T>().reserve(size_t{}))>>
-    : std::true_type {};
-```
-
-## CRTP (Curiously Recurring Template Pattern)
-
-```cpp
-// Static polymorphism with CRTP
-template<typename Derived>
-class Shape {
-public:
-    double area() const {
-        return static_cast<const Derived*>(this)->area_impl();
-    }
-
-    void draw() const {
-        static_cast<const Derived*>(this)->draw_impl();
-    }
-};
-
-class Circle : public Shape<Circle> {
-    double radius_;
-public:
-    Circle(double r) : radius_(r) {}
-
-    double area_impl() const {
-        return 3.14159 * radius_ * radius_;
-    }
-
-    void draw_impl() const {
-        std::cout << "Drawing circle\n";
-    }
-};
-
-class Rectangle : public Shape<Rectangle> {
-    double width_, height_;
-public:
-    Rectangle(double w, double h) : width_(w), height_(h) {}
-
-    double area_impl() const {
-        return width_ * height_;
-    }
-
-    void draw_impl() const {
-        std::cout << "Drawing rectangle\n";
-    }
-};
-
-// CRTP for mixin capabilities
-template<typename Derived>
-class Printable {
-public:
-    void print() const {
-        std::cout << static_cast<const Derived*>(this)->to_string() << '\n';
-    }
-};
-
-class User : public Printable<User> {
-    std::string name_;
-public:
-    User(std::string name) : name_(std::move(name)) {}
-
-    std::string to_string() const {
-        return "User: " + name_;
-    }
-};
-```
-
-## Template Template Parameters
-
-```cpp
-#include <vector>
-#include <list>
-#include <deque>
-
-// Template template parameter
-template<typename T, template<typename, typename> class Container>
-class Stack {
-    Container<T, std::allocator<T>> data_;
-
-public:
-    void push(const T& value) {
-        data_.push_back(value);
-    }
-
-    T pop() {
-        T value = data_.back();
-        data_.pop_back();
-        return value;
-    }
-
-    size_t size() const {
-        return data_.size();
-    }
-};
-
-// Usage with different containers
-Stack<int, std::vector> vector_stack;
-Stack<int, std::deque> deque_stack;
-Stack<int, std::list> list_stack;
-```
-
-## Compile-Time Computation
-
-```cpp
-#include <array>
-
-// Compile-time factorial
-constexpr int factorial(int n) {
-    return n <= 1 ? 1 : n * factorial(n - 1);
-}
-
-constexpr int fact_5 = factorial(5);  // Computed at compile time
-
-// Compile-time prime checking
-constexpr bool is_prime(int n) {
-    if (n < 2) return false;
-    for (int i = 2; i * i <= n; ++i) {
-        if (n % i == 0) return false;
-    }
-    return true;
-}
-
-// Generate compile-time array of primes
-template<size_t N>
-constexpr auto generate_primes() {
-    std::array<int, N> primes{};
-    int count = 0;
-    int candidate = 2;
-
-    while (count < N) {
-        if (is_prime(candidate)) {
-            primes[count++] = candidate;
-        }
-        ++candidate;
-    }
-
-    return primes;
-}
-
-constexpr auto first_10_primes = generate_primes<10>();
-```
-
-## Expression Templates
-
-```cpp
-// Lazy evaluation with expression templates
-template<typename E>
-class VecExpression {
-public:
-    double operator[](size_t i) const {
-        return static_cast<const E&>(*this)[i];
-    }
-
-    size_t size() const {
-        return static_cast<const E&>(*this).size();
-    }
-};
-
-class Vec : public VecExpression<Vec> {
-    std::vector<double> data_;
-
-public:
-    Vec(size_t n) : data_(n) {}
-
-    double operator[](size_t i) const { return data_[i]; }
-    double& operator[](size_t i) { return data_[i]; }
-    size_t size() const { return data_.size(); }
-
-    // Evaluate expression template
-    template<typename E>
-    Vec& operator=(const VecExpression<E>& expr) {
-        for (size_t i = 0; i < size(); ++i) {
-            data_[i] = expr[i];
-        }
-        return *this;
-    }
-};
-
-// Binary operation expression
-template<typename E1, typename E2>
-class VecSum : public VecExpression<VecSum<E1, E2>> {
-    const E1& lhs_;
-    const E2& rhs_;
-
-public:
-    VecSum(const E1& lhs, const E2& rhs) : lhs_(lhs), rhs_(rhs) {}
-
-    double operator[](size_t i) const {
-        return lhs_[i] + rhs_[i];
-    }
-
-    size_t size() const { return lhs_.size(); }
-};
-
-// Operator overload
-template<typename E1, typename E2>
-VecSum<E1, E2> operator+(const VecExpression<E1>& lhs,
-                         const VecExpression<E2>& rhs) {
-    return VecSum<E1, E2>(static_cast<const E1&>(lhs),
-                          static_cast<const E2&>(rhs));
-}
-
-// Usage: a = b + c + d  (no temporaries created!)
-```
-
-## Quick Reference
-
-| Technique | Use Case | Performance |
-|-----------|----------|-------------|
-| Variadic Templates | Variable arguments | Zero overhead |
-| SFINAE | Conditional compilation | Compile-time |
-| if constexpr | Type-based branching | Zero overhead |
-| CRTP | Static polymorphism | No vtable cost |
-| Expression Templates | Lazy evaluation | Eliminates temps |
-| Type Traits | Type introspection | Compile-time |
-| Fold Expressions | Parameter pack ops | Optimal |
-| Template Specialization | Type-specific impl | Zero overhead |

package/skills/csharp-developer/SKILL.md

@@ -1,125 +0,0 @@
----
-name: csharp-developer
-description: "Use when building C# applications with .NET 8+, ASP.NET Core APIs, or Blazor web apps. Builds REST APIs using minimal or controller-based routing, configures database access with Entity Framework Core, implements async patterns and cancellation, structures applications with CQRS via MediatR, and scaffolds Blazor components with state management. Invoke for C#, .NET, ASP.NET Core, Blazor, Entity Framework, EF Core, Minimal API, MAUI, SignalR."
-license: MIT
-metadata:
-  author: https://github.com/Jeffallan
-  version: "1.1.0"
-  domain: language
-  triggers: C#, .NET, ASP.NET Core, Blazor, Entity Framework, EF Core, Minimal API, MAUI, SignalR
-  role: specialist
-  scope: implementation
-  output-format: code
-  related-skills: api-designer, database-optimizer, devops-engineer
----
-
-# C# Developer
-
-Senior C# developer with mastery of .NET 8+ and Microsoft ecosystem. Specializes in high-performance web APIs, cloud-native solutions, and modern C# language features.
-
-## When to Use This Skill
-
-- Building ASP.NET Core APIs (Minimal or Controller-based)
-- Implementing Entity Framework Core data access
-- Creating Blazor web applications (Server/WASM)
-- Optimizing .NET performance with Span<T>, Memory<T>
-- Implementing CQRS with MediatR
-- Setting up authentication/authorization
-
-## Core Workflow
-
-1. **Analyze solution** — Review .csproj files, NuGet packages, architecture
-2. **Design models** — Create domain models, DTOs, validation
-3. **Implement** — Write endpoints, repositories, services with DI
-4. **Optimize** — Apply async patterns, caching, performance tuning
-5. **Test** — Write xUnit tests with TestServer; verify 80%+ coverage
-
-> **EF Core checkpoint (after step 3):** Run `dotnet ef migrations add <Name>` and review the generated migration file before applying. Confirm no unintended table/column drops. Roll back with `dotnet ef migrations remove` if needed.
-
-## Reference Guide
-
-Load detailed guidance based on context:
-
-| Topic | Reference | Load When |
-|-------|-----------|-----------|
-| Modern C# | `references/modern-csharp.md` | Records, pattern matching, nullable types |
-| ASP.NET Core | `references/aspnet-core.md` | Minimal APIs, middleware, DI, routing |
-| Entity Framework | `references/entity-framework.md` | EF Core, migrations, query optimization |
-| Blazor | `references/blazor.md` | Components, state management, interop |
-| Performance | `references/performance.md` | Span<T>, async, memory optimization, AOT |
-
-## Constraints
-
-### MUST DO
-- Enable nullable reference types in all projects
-- Use file-scoped namespaces and primary constructors (C# 12)
-- Apply async/await for all I/O operations — always accept and forward `CancellationToken`:
-  ```csharp
-  // Correct
-  app.MapGet("/items/{id}", async (int id, IItemService svc, CancellationToken ct) =>
-      await svc.GetByIdAsync(id, ct) is { } item ? Results.Ok(item) : Results.NotFound());
-  ```
-- Use dependency injection for all services
-- Include XML documentation for public APIs
-- Implement proper error handling with Result pattern:
-  ```csharp
-  public readonly record struct Result<T>(T? Value, string? Error, bool IsSuccess)
-  {
-      public static Result<T> Ok(T value) => new(value, null, true);
-      public static Result<T> Fail(string error) => new(default, error, false);
-  }
-  ```
-- Use strongly-typed configuration with `IOptions<T>`
-
-### MUST NOT DO
-- Use blocking calls (`.Result`, `.Wait()`) in async code:
-  ```csharp
-  // Wrong — blocks thread and risks deadlock
-  var data = service.GetDataAsync().Result;
-
-  // Correct
-  var data = await service.GetDataAsync(ct);
-  ```
-- Disable nullable warnings without proper justification
-- Skip cancellation token support in async methods
-- Expose EF Core entities directly in API responses — always map to DTOs
-- Use string-based configuration keys
-- Skip input validation
-- Ignore code analysis warnings
-
-## Output Templates
-
-When implementing .NET features, provide:
-1. Domain models and DTOs
-2. API endpoints (Minimal API or controllers)
-3. Repository/service implementations
-4. Configuration setup (Program.cs, appsettings.json)
-5. Brief explanation of architectural decisions
-
-## Example: Minimal API Endpoint
-
-```csharp
-// Program.cs (file-scoped, .NET 8 minimal API)
-var builder = WebApplication.CreateBuilder(args);
-builder.Services.AddScoped<IProductService, ProductService>();
-
-var app = builder.Build();
-
-app.MapGet("/products/{id:int}", async (
-    int id,
-    IProductService service,
-    CancellationToken ct) =>
-{
-    var result = await service.GetByIdAsync(id, ct);
-    return result.IsSuccess ? Results.Ok(result.Value) : Results.NotFound(result.Error);
-})
-.WithName("GetProduct")
-.Produces<ProductDto>()
-.ProducesProblem(404);
-
-app.Run();
-```
-
-## Knowledge Reference
-
-C# 12, .NET 8, ASP.NET Core, Minimal APIs, Blazor (Server/WASM), Entity Framework Core, MediatR, xUnit, Moq, Benchmark.NET, SignalR, gRPC, Azure SDK, Polly, FluentValidation, Serilog