agentic-team-templates 0.13.2 → 0.14.0

package/README.md

@@ -148,13 +148,17 @@ npx agentic-team-templates --reset --force
 | Template | Description |
 |----------|-------------|
 | `blockchain` | Smart contracts, DeFi protocols, and Web3 applications (Solidity, Foundry, Viem) |
+| `cpp-expert` | Principal-level C++ engineering (modern C++, RAII, concurrency, templates, performance) |
+| `csharp-expert` | Principal-level C# engineering (async, DI, EF Core, ASP.NET Core, testing) |
 | `cli-tools` | Command-line applications and developer tools (Cobra, Commander, Click) |
 | `data-engineering` | Data platforms and pipelines (ETL, data modeling, data quality) |
 | `devops-sre` | DevOps and SRE practices (incident management, observability, SLOs, chaos engineering) |
 | `documentation` | Technical documentation standards (READMEs, API docs, ADRs, code comments) |
 | `fullstack` | Full-stack web applications (Next.js, Nuxt, SvelteKit, Remix) |
 | `golang-expert` | Principal-level Go engineering (concurrency, stdlib, production patterns, testing) |
-| `javascript-expert` | Principal-level JavaScript engineering across Node.js, React, vanilla JS, and testing |
+| `kotlin-expert` | Principal-level Kotlin engineering (coroutines, multiplatform, Ktor, Spring Boot, testing) |
+| `javascript-expert` | Principal-level JavaScript & TypeScript engineering (Node.js, React, type system, testing) |
+| `java-expert` | Principal-level Java engineering (JVM, Spring Boot, concurrency, JPA, testing) |
 | `ml-ai` | Machine learning and AI systems (model development, deployment, monitoring) |
 | `mobile` | Mobile applications (React Native, Flutter, native iOS/Android) |
 | `platform-engineering` | Internal developer platforms, infrastructure automation, reliability engineering |
@@ -162,6 +166,7 @@ npx agentic-team-templates --reset --force
 | `python-expert` | Principal-level Python engineering (type system, async, testing, FastAPI, Django) |
 | `qa-engineering` | Quality assurance programs for confident, rapid software delivery |
 | `rust-expert` | Principal-level Rust engineering (ownership, concurrency, unsafe, traits, async) |
+| `swift-expert` | Principal-level Swift engineering (concurrency, SwiftUI, protocols, testing, Apple platforms) |
 | `testing` | Comprehensive testing practices (TDD, test design, CI/CD integration, performance testing) |
 | `utility-agent` | AI agent utilities with context management and hallucination prevention |
 | `web-backend` | Backend APIs and services (REST, GraphQL, microservices) |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-team-templates",
-  "version": "0.13.2",
+  "version": "0.14.0",
   "description": "AI coding assistant templates for Cursor IDE. Pre-configured rules and guidelines that help AI assistants write better code. - use at your own risk",
   "keywords": [
     "cursor",

package/src/index.js

@@ -24,6 +24,14 @@ const TEMPLATES = {
     description: 'Smart contracts, DeFi protocols, and Web3 applications (Solidity, Foundry, Viem)',
     rules: ['defi-patterns.md', 'gas-optimization.md', 'overview.md', 'security.md', 'smart-contracts.md', 'testing.md', 'web3-integration.md']
   },
+  'cpp-expert': {
+    description: 'Principal-level C++ engineering (modern C++, RAII, concurrency, templates, performance)',
+    rules: ['concurrency.md', 'error-handling.md', 'memory-and-ownership.md', 'modern-cpp.md', 'overview.md', 'performance.md', 'testing.md', 'tooling.md']
+  },
+  'csharp-expert': {
+    description: 'Principal-level C# engineering (async, DI, EF Core, ASP.NET Core, testing)',
+    rules: ['aspnet-core.md', 'async-patterns.md', 'dependency-injection.md', 'error-handling.md', 'language-features.md', 'overview.md', 'performance.md', 'testing.md', 'tooling.md']
+  },
   'cli-tools': {
     description: 'Command-line applications and developer tools (Cobra, Commander, Click)',
     rules: ['architecture.md', 'arguments.md', 'distribution.md', 'error-handling.md', 'overview.md', 'testing.md', 'user-experience.md']
@@ -48,9 +56,17 @@ const TEMPLATES = {
     description: 'Principal-level Go engineering (concurrency, stdlib, production patterns, testing)',
     rules: ['concurrency.md', 'error-handling.md', 'interfaces-and-types.md', 'overview.md', 'performance.md', 'production-patterns.md', 'stdlib-and-tooling.md', 'testing.md']
   },
+  'java-expert': {
+    description: 'Principal-level Java engineering (JVM, Spring Boot, concurrency, JPA, testing)',
+    rules: ['concurrency.md', 'error-handling.md', 'modern-java.md', 'overview.md', 'performance.md', 'persistence.md', 'spring-boot.md', 'testing.md', 'tooling.md']
+  },
   'javascript-expert': {
-    description: 'Principal-level JavaScript engineering across Node.js, React, vanilla JS, and testing',
-    rules: ['language-deep-dive.md', 'node-patterns.md', 'overview.md', 'performance.md', 'react-patterns.md', 'testing.md', 'tooling.md']
+    description: 'Principal-level JavaScript & TypeScript engineering (Node.js, React, type system, testing)',
+    rules: ['language-deep-dive.md', 'node-patterns.md', 'overview.md', 'performance.md', 'react-patterns.md', 'testing.md', 'tooling.md', 'typescript-deep-dive.md']
+  },
+  'kotlin-expert': {
+    description: 'Principal-level Kotlin engineering (coroutines, multiplatform, Ktor, Spring Boot, testing)',
+    rules: ['coroutines.md', 'error-handling.md', 'frameworks.md', 'language-features.md', 'overview.md', 'performance.md', 'testing.md', 'tooling.md']
   },
   'ml-ai': {
     description: 'Machine learning and AI systems (model development, deployment, monitoring)',
@@ -80,6 +96,10 @@ const TEMPLATES = {
     description: 'Principal-level Rust engineering (ownership, concurrency, unsafe, traits, async)',
     rules: ['concurrency.md', 'ecosystem-and-tooling.md', 'error-handling.md', 'overview.md', 'ownership-and-borrowing.md', 'performance-and-unsafe.md', 'testing.md', 'traits-and-generics.md']
   },
+  'swift-expert': {
+    description: 'Principal-level Swift engineering (concurrency, SwiftUI, protocols, testing, Apple platforms)',
+    rules: ['concurrency.md', 'error-handling.md', 'language-features.md', 'overview.md', 'performance.md', 'swiftui.md', 'testing.md', 'tooling.md']
+  },
   'testing': {
     description: 'Comprehensive testing practices (TDD, test design, CI/CD integration, performance testing)',
     rules: ['advanced-techniques.md', 'ci-cd-integration.md', 'overview.md', 'performance-testing.md', 'quality-metrics.md', 'reliability.md', 'tdd-methodology.md', 'test-data.md', 'test-design.md', 'test-types.md']

package/src/index.test.js

@@ -74,13 +74,17 @@ describe('Constants', () => {
     it('should have all expected templates', () => {
       const expectedTemplates = [
         'blockchain',
+        'cpp-expert',
+        'csharp-expert',
         'cli-tools',
         'data-engineering',
         'devops-sre',
         'documentation',
         'fullstack',
         'golang-expert',
+        'java-expert',
         'javascript-expert',
+        'kotlin-expert',
         'ml-ai',
         'mobile',
         'platform-engineering',
@@ -88,6 +92,7 @@ describe('Constants', () => {
         'python-expert',
         'qa-engineering',
         'rust-expert',
+        'swift-expert',
         'testing',
         'utility-agent',
         'web-backend',

package/templates/cpp-expert/.cursorrules/concurrency.md

@@ -0,0 +1,211 @@
+# C++ Concurrency
+
+The C++ memory model is the law. Every concurrent access must be explicitly synchronized.
+
+## std::thread and std::jthread
+
+```cpp
+// std::jthread (C++20) — automatically joins on destruction
+void process_data(std::stop_token stop, std::span<const Item> items) {
+    for (const auto& item : items) {
+        if (stop.stop_requested()) return;
+        process(item);
+    }
+}
+
+auto worker = std::jthread(process_data, data);
+// Automatically joins when worker goes out of scope
+// Can request stop: worker.request_stop();
+
+// Never use std::thread without join/detach — it calls std::terminate
+```
+
+## Mutex and Locking
+
+```cpp
+// RAII locking — always
+class ThreadSafeCounter {
+    mutable std::mutex mutex_;
+    int count_ = 0;
+
+public:
+    void increment() {
+        std::lock_guard lock(mutex_);
+        ++count_;
+    }
+
+    int get() const {
+        std::lock_guard lock(mutex_);
+        return count_;
+    }
+};
+
+// Multiple mutexes — use std::scoped_lock to avoid deadlock
+void transfer(Account& from, Account& to, int amount) {
+    std::scoped_lock lock(from.mutex_, to.mutex_); // Deadlock-free
+    from.balance_ -= amount;
+    to.balance_ += amount;
+}
+
+// Read-heavy workloads — use shared_mutex
+class Cache {
+    mutable std::shared_mutex mutex_;
+    std::unordered_map<std::string, Value> data_;
+
+public:
+    auto get(const std::string& key) const -> std::optional<Value> {
+        std::shared_lock lock(mutex_); // Multiple readers OK
+        auto it = data_.find(key);
+        return it != data_.end() ? std::optional{it->second} : std::nullopt;
+    }
+
+    void set(const std::string& key, Value value) {
+        std::unique_lock lock(mutex_); // Exclusive write
+        data_[key] = std::move(value);
+    }
+};
+```
+
+## Atomics
+
+```cpp
+// Lock-free operations for simple types
+std::atomic<int> counter{0};
+counter.fetch_add(1, std::memory_order_relaxed); // Fastest for counters
+
+// Flags
+std::atomic<bool> ready{false};
+// Producer:
+data = prepare();
+ready.store(true, std::memory_order_release);
+// Consumer:
+while (!ready.load(std::memory_order_acquire)) { /* spin or yield */ }
+use(data); // Guaranteed to see prepared data
+
+// std::atomic_ref (C++20) for non-atomic variables
+int value = 0;
+std::atomic_ref ref{value};
+ref.fetch_add(1);
+```
+
+## Condition Variables
+
+```cpp
+template <typename T>
+class BoundedQueue {
+    std::queue<T> queue_;
+    mutable std::mutex mutex_;
+    std::condition_variable not_empty_;
+    std::condition_variable not_full_;
+    size_t max_size_;
+
+public:
+    explicit BoundedQueue(size_t max_size) : max_size_{max_size} {}
+
+    void push(T item) {
+        std::unique_lock lock(mutex_);
+        not_full_.wait(lock, [this] { return queue_.size() < max_size_; });
+        queue_.push(std::move(item));
+        not_empty_.notify_one();
+    }
+
+    auto pop() -> T {
+        std::unique_lock lock(mutex_);
+        not_empty_.wait(lock, [this] { return !queue_.empty(); });
+        auto item = std::move(queue_.front());
+        queue_.pop();
+        not_full_.notify_one();
+        return item;
+    }
+
+    auto try_pop(std::chrono::milliseconds timeout) -> std::optional<T> {
+        std::unique_lock lock(mutex_);
+        if (!not_empty_.wait_for(lock, timeout, [this] { return !queue_.empty(); })) {
+            return std::nullopt;
+        }
+        auto item = std::move(queue_.front());
+        queue_.pop();
+        not_full_.notify_one();
+        return item;
+    }
+};
+```
+
+## Async and Futures
+
+```cpp
+// std::async for fire-and-forget parallel work
+auto future = std::async(std::launch::async, [] {
+    return expensive_computation();
+});
+
+auto result = future.get(); // Blocks until ready
+
+// Parallel independent work
+auto user_future = std::async(std::launch::async, [&] { return fetch_user(id); });
+auto orders_future = std::async(std::launch::async, [&] { return fetch_orders(id); });
+
+auto user = user_future.get();
+auto orders = orders_future.get();
+```
+
+## Parallel Algorithms (C++17)
+
+```cpp
+#include <execution>
+
+// Parallel sort
+std::sort(std::execution::par, data.begin(), data.end());
+
+// Parallel transform-reduce
+auto total = std::transform_reduce(
+    std::execution::par,
+    orders.begin(), orders.end(),
+    0.0,                                        // Initial value
+    std::plus<>{},                              // Reduce
+    [](const Order& o) { return o.total(); }    // Transform
+);
+
+// Parallel for_each
+std::for_each(std::execution::par_unseq, items.begin(), items.end(),
+    [](auto& item) { item.process(); });
+```
+
+## Thread Safety Rules
+
+1. **Immutable data is thread-safe** — share freely via `const` references
+2. **Every mutable shared state needs synchronization** — no exceptions
+3. **Prefer lock-free data structures** when correctness is provable
+4. **Hold locks for the minimum time** — compute outside the critical section
+5. **Never hold two locks simultaneously** unless using `std::scoped_lock`
+6. **Use `std::atomic` for single variables**, mutex for compound operations
+
+## Anti-Patterns
+
+```cpp
+// Never: lock and forget
+mutex_.lock();
+do_work(); // If this throws, mutex stays locked forever
+mutex_.unlock();
+// Use: std::lock_guard or std::unique_lock (RAII)
+
+// Never: double-checked locking without atomics
+if (!instance) {
+    std::lock_guard lock(mutex);
+    if (!instance) instance = new Singleton(); // Data race!
+}
+// Use: std::call_once or static local (Meyers singleton)
+
+static Singleton& instance() {
+    static Singleton s; // Thread-safe in C++11+
+    return s;
+}
+
+// Never: volatile for synchronization
+volatile int flag; // volatile != atomic in C++
+// Use: std::atomic<int> flag;
+
+// Never: busy-waiting without yield
+while (!ready.load()) {} // Burns CPU
+// Use: condition_variable, or at least std::this_thread::yield()
+```

package/templates/cpp-expert/.cursorrules/error-handling.md

@@ -0,0 +1,170 @@
+# C++ Error Handling
+
+Exceptions for exceptional conditions. Error codes and std::expected for expected failures. RAII guarantees cleanup.
+
+## Exception Safety Guarantees
+
+Every function provides one of these guarantees — document which:
+
+1. **No-throw** — Function never throws. Mark `noexcept`. (Destructors, move operations, swap)
+2. **Strong** — If exception thrown, state rolls back to before the call. (Transaction semantics)
+3. **Basic** — If exception thrown, invariants preserved, no leaks. (The minimum acceptable guarantee)
+4. **No guarantee** — Avoid. This is a bug.
+
+```cpp
+// No-throw: destructors, move constructors, swap
+Buffer(Buffer&& other) noexcept;
+~Buffer() noexcept; // Implicit, but be explicit
+
+// Strong: copy-and-swap idiom
+auto operator=(Buffer other) -> Buffer& { // Takes by value (copies)
+    swap(*this, other);                    // noexcept swap
+    return *this;                          // Old data destroyed in 'other'
+}
+
+// Basic: RAII handles cleanup even if later operations throw
+void process(const std::string& path) {
+    auto file = open_file(path);    // RAII — cleaned up if next line throws
+    auto data = parse(file);        // RAII — cleaned up if next line throws
+    validate(data);                 // If this throws, file and data cleaned up
+}
+```
+
+## Exceptions
+
+```cpp
+// Throw by value, catch by const reference
+class ApplicationError : public std::runtime_error {
+    std::string code_;
+public:
+    ApplicationError(std::string code, const std::string& message)
+        : std::runtime_error(message), code_{std::move(code)} {}
+
+    const std::string& code() const noexcept { return code_; }
+};
+
+class NotFoundError : public ApplicationError {
+public:
+    NotFoundError(const std::string& entity, const std::string& id)
+        : ApplicationError("NOT_FOUND",
+            fmt::format("{} '{}' not found", entity, id)) {}
+};
+
+// Catch specific exceptions first
+try {
+    auto user = find_user(id);
+} catch (const NotFoundError& e) {
+    return http::response(404, e.what());
+} catch (const ApplicationError& e) {
+    return http::response(400, e.what());
+} catch (const std::exception& e) {
+    log::error("Unexpected error: {}", e.what());
+    return http::response(500, "Internal error");
+}
+```
+
+## std::expected (C++23)
+
+```cpp
+// For expected failures — no exception overhead
+enum class ValidationError { empty_name, invalid_email, duplicate_email };
+
+auto validate_user(const CreateUserRequest& req)
+    -> std::expected<ValidatedUser, ValidationError>
+{
+    if (req.name.empty())
+        return std::unexpected{ValidationError::empty_name};
+    if (!is_valid_email(req.email))
+        return std::unexpected{ValidationError::invalid_email};
+    return ValidatedUser{req.name, req.email};
+}
+
+// Monadic chaining
+auto result = validate_user(request)
+    .and_then([&](auto user) { return save_user(db, user); })
+    .transform([](auto saved) { return UserResponse::from(saved); });
+
+if (!result) {
+    handle_error(result.error());
+}
+```
+
+## Error Codes (C-style APIs)
+
+```cpp
+// std::error_code / std::error_condition for system-level errors
+auto read_file(const std::filesystem::path& path)
+    -> std::expected<std::string, std::error_code>
+{
+    std::error_code ec;
+    auto size = std::filesystem::file_size(path, ec);
+    if (ec) return std::unexpected{ec};
+
+    std::ifstream file(path);
+    if (!file) return std::unexpected{
+        std::make_error_code(std::errc::io_error)};
+
+    std::string content(size, '\0');
+    file.read(content.data(), static_cast<std::streamsize>(size));
+    return content;
+}
+```
+
+## noexcept
+
+```cpp
+// Mark functions noexcept when they genuinely cannot throw
+// The compiler can optimize based on this — and std::terminate if violated
+
+// Always noexcept:
+~MyClass() noexcept;                          // Destructors (implicit)
+MyClass(MyClass&& other) noexcept;            // Move constructor
+MyClass& operator=(MyClass&& other) noexcept; // Move assignment
+friend void swap(MyClass& a, MyClass& b) noexcept;
+
+// Conditional noexcept:
+template <typename T>
+void process(T&& value) noexcept(noexcept(value.do_work())) {
+    value.do_work();
+}
+
+// Why it matters: containers like std::vector will COPY instead of MOVE
+// if move constructor is not noexcept (strong exception guarantee)
+```
+
+## Assertions and Contracts
+
+```cpp
+// Debug-only checks for programmer errors (not user input)
+#include <cassert>
+
+void process(std::span<const int> data) {
+    assert(!data.empty() && "process() called with empty data");
+    // assert is removed in release builds
+}
+
+// Static assertions for compile-time invariants
+static_assert(sizeof(Packet) == 64, "Packet must be exactly 64 bytes for alignment");
+static_assert(std::is_nothrow_move_constructible_v<Buffer>,
+    "Buffer must be nothrow-movable for vector reallocation");
+```
+
+## Anti-Patterns
+
+```cpp
+// Never: catch(...) without rethrowing
+try { do_work(); }
+catch (...) { /* swallowed */ }
+// At minimum: catch (...) { log_error(); throw; }
+
+// Never: throwing in destructors
+~MyClass() { throw std::runtime_error("cleanup failed"); }
+// std::terminate will be called. Log and continue.
+
+// Never: exceptions across DLL/shared library boundaries (ABI mismatch)
+// Use error codes or std::expected at library boundaries
+
+// Never: using exception specifications (deprecated)
+void func() throw(std::exception); // Deprecated and removed in C++17
+// Use: noexcept or nothing
+```