moai-adk 0.32.8__py3-none-any.whl → 0.41.2__py3-none-any.whl

moai_adk/templates/.claude/skills/moai-lang-cpp/modules/advanced-patterns.md

@@ -0,0 +1,401 @@
+# C++ Advanced Patterns
+
+## Template Metaprogramming
+
+Variadic Templates:
+```cpp
+template<typename... Args>
+auto sum(Args... args) {
+    return (args + ...);  // Fold expression
+}
+
+template<typename... Args>
+void print_all(Args&&... args) {
+    ((std::cout << std::forward<Args>(args) << " "), ...);
+}
+```
+
+SFINAE and if constexpr:
+```cpp
+template<typename T>
+auto to_string(const T& value) -> std::string {
+    if constexpr (std::is_arithmetic_v<T>) {
+        return std::to_string(value);
+    } else if constexpr (requires { value.to_string(); }) {
+        return value.to_string();
+    } else {
+        return "unknown";
+    }
+}
+```
+
+## Testing with Google Test
+
+Complete Test Suite:
+```cpp
+#include <gtest/gtest.h>
+
+class CalculatorTest : public ::testing::Test {
+protected:
+    Calculator calc;
+
+    void SetUp() override {
+        calc = Calculator{};
+    }
+};
+
+TEST_F(CalculatorTest, Addition) {
+    EXPECT_EQ(calc.add(2, 3), 5);
+}
+
+TEST_F(CalculatorTest, DivisionByZero) {
+    EXPECT_THROW(calc.divide(1, 0), std::invalid_argument);
+}
+
+// Parameterized test
+class AdditionTest : public ::testing::TestWithParam<std::tuple<int, int, int>> {};
+
+TEST_P(AdditionTest, Works) {
+    auto [a, b, expected] = GetParam();
+    EXPECT_EQ(Calculator{}.add(a, b), expected);
+}
+
+INSTANTIATE_TEST_SUITE_P(Basics, AdditionTest,
+    ::testing::Values(
+        std::make_tuple(1, 1, 2),
+        std::make_tuple(0, 0, 0),
+        std::make_tuple(-1, 1, 0)
+    ));
+```
+
+## Catch2 Testing Framework
+
+Alternative Testing:
+```cpp
+#include <catch2/catch_test_macros.hpp>
+
+TEST_CASE("Vector operations", "[vector]") {
+    std::vector<int> v;
+
+    SECTION("starts empty") {
+        REQUIRE(v.empty());
+    }
+
+    SECTION("can add elements") {
+        v.push_back(1);
+        REQUIRE(v.size() == 1);
+        REQUIRE(v[0] == 1);
+    }
+
+    SECTION("can be resized") {
+        v.resize(10);
+        REQUIRE(v.size() == 10);
+    }
+}
+
+TEST_CASE("Generators", "[generator]") {
+    auto i = GENERATE(range(1, 10));
+    REQUIRE(i > 0);
+    REQUIRE(i < 10);
+}
+```
+
+## Advanced Concurrency
+
+Thread Pool Implementation:
+```cpp
+#include <thread>
+#include <queue>
+#include <functional>
+#include <future>
+#include <condition_variable>
+
+class ThreadPool {
+public:
+    explicit ThreadPool(size_t num_threads) : stop_(false) {
+        for (size_t i = 0; i < num_threads; ++i) {
+            workers_.emplace_back([this] {
+                while (true) {
+                    std::function<void()> task;
+                    {
+                        std::unique_lock lock(mutex_);
+                        cv_.wait(lock, [this] { return stop_ || !tasks_.empty(); });
+                        if (stop_ && tasks_.empty()) return;
+                        task = std::move(tasks_.front());
+                        tasks_.pop();
+                    }
+                    task();
+                }
+            });
+        }
+    }
+
+    template<typename F, typename... Args>
+    auto enqueue(F&& f, Args&&... args) -> std::future<std::invoke_result_t<F, Args...>> {
+        using return_type = std::invoke_result_t<F, Args...>;
+        auto task = std::make_shared<std::packaged_task<return_type()>>(
+            std::bind(std::forward<F>(f), std::forward<Args>(args)...));
+        auto result = task->get_future();
+        {
+            std::unique_lock lock(mutex_);
+            tasks_.emplace([task] { (*task)(); });
+        }
+        cv_.notify_one();
+        return result;
+    }
+
+    ~ThreadPool() {
+        {
+            std::unique_lock lock(mutex_);
+            stop_ = true;
+        }
+        cv_.notify_all();
+        for (auto& worker : workers_) {
+            worker.join();
+        }
+    }
+
+private:
+    std::vector<std::thread> workers_;
+    std::queue<std::function<void()>> tasks_;
+    std::mutex mutex_;
+    std::condition_variable cv_;
+    bool stop_;
+};
+```
+
+Lock-Free Queue:
+```cpp
+#include <atomic>
+#include <optional>
+
+template<typename T>
+class LockFreeQueue {
+    struct Node {
+        std::optional<T> data;
+        std::atomic<Node*> next;
+    };
+
+    std::atomic<Node*> head_;
+    std::atomic<Node*> tail_;
+
+public:
+    LockFreeQueue() {
+        auto* dummy = new Node{std::nullopt, nullptr};
+        head_.store(dummy);
+        tail_.store(dummy);
+    }
+
+    void push(T value) {
+        auto* new_node = new Node{std::move(value), nullptr};
+        Node* old_tail;
+        while (true) {
+            old_tail = tail_.load();
+            Node* null_node = nullptr;
+            if (old_tail->next.compare_exchange_weak(null_node, new_node)) {
+                break;
+            }
+            tail_.compare_exchange_weak(old_tail, old_tail->next);
+        }
+        tail_.compare_exchange_weak(old_tail, new_node);
+    }
+
+    auto pop() -> std::optional<T> {
+        Node* old_head;
+        while (true) {
+            old_head = head_.load();
+            Node* old_tail = tail_.load();
+            Node* next = old_head->next.load();
+            if (old_head == old_tail) {
+                if (next == nullptr) return std::nullopt;
+                tail_.compare_exchange_weak(old_tail, next);
+            } else {
+                if (head_.compare_exchange_weak(old_head, next)) {
+                    auto result = std::move(next->data);
+                    delete old_head;
+                    return result;
+                }
+            }
+        }
+    }
+};
+```
+
+## Memory Management Patterns
+
+Custom Allocator:
+```cpp
+template<typename T>
+class PoolAllocator {
+    struct Block {
+        Block* next;
+    };
+
+    Block* free_list_ = nullptr;
+    std::vector<std::unique_ptr<std::byte[]>> pools_;
+    size_t block_size_ = std::max(sizeof(T), sizeof(Block));
+    size_t pool_size_ = 1024;
+
+public:
+    using value_type = T;
+
+    auto allocate(size_t n) -> T* {
+        if (n != 1) throw std::bad_alloc();
+        if (!free_list_) allocate_pool();
+        Block* block = free_list_;
+        free_list_ = block->next;
+        return reinterpret_cast<T*>(block);
+    }
+
+    void deallocate(T* p, size_t) {
+        Block* block = reinterpret_cast<Block*>(p);
+        block->next = free_list_;
+        free_list_ = block;
+    }
+
+private:
+    void allocate_pool() {
+        auto pool = std::make_unique<std::byte[]>(block_size_ * pool_size_);
+        for (size_t i = 0; i < pool_size_; ++i) {
+            Block* block = reinterpret_cast<Block*>(pool.get() + i * block_size_);
+            block->next = free_list_;
+            free_list_ = block;
+        }
+        pools_.push_back(std::move(pool));
+    }
+};
+```
+
+## Production Patterns
+
+Dependency Injection:
+```cpp
+// Interface
+class ILogger {
+public:
+    virtual ~ILogger() = default;
+    virtual void log(std::string_view message) = 0;
+};
+
+// Implementation
+class ConsoleLogger : public ILogger {
+public:
+    void log(std::string_view message) override {
+        std::println("{}", message);
+    }
+};
+
+// Service using dependency injection
+class UserService {
+    std::shared_ptr<ILogger> logger_;
+
+public:
+    explicit UserService(std::shared_ptr<ILogger> logger)
+        : logger_(std::move(logger)) {}
+
+    void create_user(std::string_view name) {
+        logger_->log(std::format("Creating user: {}", name));
+        // Business logic
+    }
+};
+
+// Factory
+class ServiceFactory {
+public:
+    static auto create_user_service() -> std::unique_ptr<UserService> {
+        return std::make_unique<UserService>(
+            std::make_shared<ConsoleLogger>()
+        );
+    }
+};
+```
+
+## Build System Patterns
+
+Conan 2.0 Integration:
+```python
+# conanfile.py
+from conan import ConanFile
+from conan.tools.cmake import CMake, cmake_layout
+
+class MyProjectConan(ConanFile):
+    name = "myproject"
+    version = "1.0.0"
+    settings = "os", "compiler", "build_type", "arch"
+    generators = "CMakeToolchain", "CMakeDeps"
+    requires = "fmt/10.2.1", "nlohmann_json/3.11.3"
+    tool_requires = "gtest/1.14.0"
+
+    def layout(self):
+        cmake_layout(self)
+
+    def build(self):
+        cmake = CMake(self)
+        cmake.configure()
+        cmake.build()
+```
+
+vcpkg Manifest:
+```json
+{
+    "$schema": "https://raw.githubusercontent.com/microsoft/vcpkg-tool/main/docs/vcpkg.schema.json",
+    "name": "myproject",
+    "version": "1.0.0",
+    "dependencies": [
+        "fmt",
+        "nlohmann-json",
+        "spdlog",
+        { "name": "gtest", "features": [ "gmock" ] }
+    ]
+}
+```
+
+## Performance Optimization
+
+Cache-Friendly Data Structures:
+```cpp
+// Structure of Arrays (SoA) for better cache performance
+struct Particles {
+    std::vector<float> x;
+    std::vector<float> y;
+    std::vector<float> z;
+    std::vector<float> vx;
+    std::vector<float> vy;
+    std::vector<float> vz;
+
+    void update(float dt) {
+        // Process all x values together (cache-friendly)
+        for (size_t i = 0; i < x.size(); ++i) {
+            x[i] += vx[i] * dt;
+        }
+        // Then y values
+        for (size_t i = 0; i < y.size(); ++i) {
+            y[i] += vy[i] * dt;
+        }
+        // Then z values
+        for (size_t i = 0; i < z.size(); ++i) {
+            z[i] += vz[i] * dt;
+        }
+    }
+};
+```
+
+SIMD Optimization:
+```cpp
+#include <immintrin.h>
+
+void add_vectors_simd(float* a, float* b, float* result, size_t n) {
+    size_t i = 0;
+    // Process 8 floats at a time using AVX
+    for (; i + 7 < n; i += 8) {
+        __m256 va = _mm256_loadu_ps(a + i);
+        __m256 vb = _mm256_loadu_ps(b + i);
+        __m256 vr = _mm256_add_ps(va, vb);
+        _mm256_storeu_ps(result + i, vr);
+    }
+    // Handle remaining elements
+    for (; i < n; ++i) {
+        result[i] = a[i] + b[i];
+    }
+}
+```

moai_adk/templates/.claude/skills/moai-lang-cpp/reference.md

@@ -0,0 +1,17 @@
+# Reference: moai-lang-cpp
+
+> **Last Updated**: 2026-01-06
+
+---
+
+## API Reference
+
+TODO: Add API reference documentation.
+
+## Configuration
+
+TODO: Add configuration options.
+
+## Troubleshooting
+
+TODO: Add common issues and solutions.

moai_adk/templates/.claude/skills/moai-lang-csharp/SKILL.md

@@ -0,0 +1,194 @@
+---
+name: "moai-lang-csharp"
+description: "C# 12 / .NET 8 development specialist covering ASP.NET Core, Entity Framework, Blazor, and modern C# patterns. Use when developing .NET APIs, web applications, or enterprise solutions."
+version: 2.0.0
+category: "language"
+modularized: true
+user-invocable: false
+allowed-tools:
+  - Read
+  - Grep
+  - Glob
+  - mcp__context7__resolve-library-id
+  - mcp__context7__get-library-docs
+context7-libraries: ['/dotnet/aspnetcore', '/dotnet/efcore', '/dotnet/runtime']
+updated: 2026-01-08
+status: "active"
+---
+
+# C# 12 / .NET 8 Development Specialist
+
+Modern C# development with ASP.NET Core, Entity Framework Core, Blazor, and enterprise patterns.
+
+## Quick Reference
+
+Auto-Triggers: `.cs`, `.csproj`, `.sln` files, C# projects, .NET solutions, ASP.NET Core applications
+
+Core Stack:
+- C# 12: Primary constructors, collection expressions, alias any type, default lambda parameters
+- .NET 8: Minimal APIs, Native AOT, improved performance, WebSockets
+- ASP.NET Core 8: Controllers, Endpoints, Middleware, Authentication
+- Entity Framework Core 8: DbContext, migrations, LINQ, query optimization
+- Blazor: Server/WASM components, InteractiveServer, InteractiveWebAssembly
+- Testing: xUnit, NUnit, FluentAssertions, Moq
+
+Quick Commands:
+```bash
+# Create .NET 8 Web API project
+dotnet new webapi -n MyApi --framework net8.0
+
+# Create Blazor Web App
+dotnet new blazor -n MyBlazor --interactivity Auto
+
+# Add Entity Framework Core
+dotnet add package Microsoft.EntityFrameworkCore.SqlServer
+dotnet add package Microsoft.EntityFrameworkCore.Design
+
+# Add FluentValidation and MediatR
+dotnet add package FluentValidation.AspNetCore
+dotnet add package MediatR
+```
+
+---
+
+## Module Index
+
+This skill uses progressive disclosure with specialized modules for deep coverage:
+
+### Language Features
+- [C# 12 Features](modules/csharp12-features.md) - Primary constructors, collection expressions, type aliases, default lambdas
+
+### Web Development
+- [ASP.NET Core 8](modules/aspnet-core.md) - Minimal API, Controllers, Middleware, Authentication
+- [Blazor Components](modules/blazor-components.md) - Server, WASM, InteractiveServer, Components
+
+### Data Access
+- [Entity Framework Core 8](modules/efcore-patterns.md) - DbContext, Repository pattern, Migrations, Query optimization
+
+### Architecture Patterns
+- [CQRS and Validation](modules/cqrs-validation.md) - MediatR CQRS, FluentValidation, Handler patterns
+
+### Reference Materials
+- [API Reference](reference.md) - Complete API reference, Context7 library mappings
+- [Code Examples](examples.md) - Production-ready examples, testing templates
+
+---
+
+## Implementation Quick Start
+
+### Project Structure (Clean Architecture)
+
+```
+src/
+├── MyApp.Api/              # ASP.NET Core Web API
+│   ├── Controllers/        # API Controllers
+│   ├── Endpoints/          # Minimal API endpoints
+│   └── Program.cs          # Application entry
+├── MyApp.Application/      # Business logic layer
+│   ├── Commands/           # CQRS Commands
+│   ├── Queries/            # CQRS Queries
+│   └── Validators/         # FluentValidation
+├── MyApp.Domain/           # Domain entities
+│   ├── Entities/           # Domain models
+│   └── Interfaces/         # Repository interfaces
+└── MyApp.Infrastructure/   # Data access layer
+    ├── Data/               # DbContext
+    └── Repositories/       # Repository implementations
+```
+
+### Essential Patterns
+
+Primary Constructor with DI:
+```csharp
+public class UserService(IUserRepository repository, ILogger<UserService> logger)
+{
+    public async Task<User?> GetByIdAsync(Guid id)
+    {
+        logger.LogInformation("Fetching user {UserId}", id);
+        return await repository.FindByIdAsync(id);
+    }
+}
+```
+
+Minimal API Endpoint:
+```csharp
+app.MapGet("/api/users/{id:guid}", async (Guid id, IUserService service) =>
+{
+    var user = await service.GetByIdAsync(id);
+    return user is not null ? Results.Ok(user) : Results.NotFound();
+})
+.WithName("GetUser")
+.WithOpenApi();
+```
+
+Entity Configuration:
+```csharp
+public class UserConfiguration : IEntityTypeConfiguration<User>
+{
+    public void Configure(EntityTypeBuilder<User> builder)
+    {
+        builder.HasKey(u => u.Id);
+        builder.Property(u => u.Email).HasMaxLength(256).IsRequired();
+        builder.HasIndex(u => u.Email).IsUnique();
+    }
+}
+```
+
+---
+
+## Context7 Integration
+
+For latest documentation, use Context7 MCP tools:
+
+```
+# ASP.NET Core documentation
+mcp__context7__resolve-library-id("aspnetcore")
+mcp__context7__get-library-docs("/dotnet/aspnetcore", "minimal-apis middleware")
+
+# Entity Framework Core documentation
+mcp__context7__resolve-library-id("efcore")
+mcp__context7__get-library-docs("/dotnet/efcore", "dbcontext migrations")
+
+# .NET Runtime documentation
+mcp__context7__resolve-library-id("dotnet runtime")
+mcp__context7__get-library-docs("/dotnet/runtime", "collections threading")
+```
+
+---
+
+## Quick Troubleshooting
+
+Build and Runtime:
+```bash
+dotnet build --verbosity detailed    # Detailed build output
+dotnet run --launch-profile https    # Run with HTTPS profile
+dotnet ef database update            # Apply EF migrations
+dotnet ef migrations add Initial     # Create new migration
+```
+
+Common Patterns:
+```csharp
+// Null reference handling
+var user = await context.Users.FindAsync(id);
+ArgumentNullException.ThrowIfNull(user, nameof(user));
+
+// Async enumerable for streaming
+public async IAsyncEnumerable<User> StreamUsersAsync(
+    [EnumeratorCancellation] CancellationToken ct = default)
+{
+    await foreach (var user in context.Users.AsAsyncEnumerable().WithCancellation(ct))
+    {
+        yield return user;
+    }
+}
+```
+
+---
+
+## Works Well With
+
+- `moai-domain-backend` - API design, database integration patterns
+- `moai-platform-deploy` - Azure, Docker, Kubernetes deployment
+- `moai-workflow-testing` - Testing strategies and patterns
+- `moai-foundation-quality` - Code quality standards
+- `moai-essentials-debug` - Debugging .NET applications