agentic-team-templates 0.13.2 → 0.15.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.15.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']
@@ -98,6 +118,36 @@ const TEMPLATES = {
   }
 };
 
+// Shorthand aliases for language expert templates
+const TEMPLATE_ALIASES = {
+  'js': 'javascript-expert',
+  'javascript': 'javascript-expert',
+  'ts': 'javascript-expert',
+  'typescript': 'javascript-expert',
+  'go': 'golang-expert',
+  'golang': 'golang-expert',
+  'py': 'python-expert',
+  'python': 'python-expert',
+  'rs': 'rust-expert',
+  'rust': 'rust-expert',
+  'swift': 'swift-expert',
+  'kotlin': 'kotlin-expert',
+  'kt': 'kotlin-expert',
+  'java': 'java-expert',
+  'cpp': 'cpp-expert',
+  'csharp': 'csharp-expert',
+  'cs': 'csharp-expert',
+};
+
+/**
+ * Resolve a template alias to its canonical name
+ * @param {string} name - Template name or alias
+ * @returns {string} Canonical template name
+ */
+function resolveTemplateAlias(name) {
+  return TEMPLATE_ALIASES[name] || name;
+}
+
 const SHARED_RULES = [
   'code-quality.md',
   'communication.md', 
@@ -195,7 +245,19 @@ ${colors.yellow('IDE Targets:')}
   claude         CLAUDE.md file (Claude Code, Cursor with Claude)
   codex          .github/copilot-instructions.md (GitHub Copilot)
 
+${colors.yellow('Shorthand Aliases:')}
+  js, ts, javascript, typescript → javascript-expert
+  go, golang                     → golang-expert
+  py, python                     → python-expert
+  rs, rust                       → rust-expert
+  swift                          → swift-expert
+  kotlin, kt                     → kotlin-expert
+  java                           → java-expert
+  cpp                            → cpp-expert
+  csharp, cs                     → csharp-expert
+
 ${colors.yellow('Examples:')}
+  npx cursor-templates js
   npx cursor-templates web-frontend
   npx cursor-templates web-frontend --ide=cursor
   npx cursor-templates web-frontend --ide=claude --ide=codex
@@ -217,13 +279,24 @@ ${colors.dim('CLAUDE.md: missing sections are intelligently merged (not overwrit
 }
 
 function printTemplates() {
+  // Build reverse map: canonical name -> list of aliases
+  const aliasesByTemplate = {};
+  for (const [alias, canonical] of Object.entries(TEMPLATE_ALIASES)) {
+    if (!aliasesByTemplate[canonical]) {
+      aliasesByTemplate[canonical] = [];
+    }
+    aliasesByTemplate[canonical].push(alias);
+  }
+
   console.log(colors.yellow('Available Templates:\n'));
-  
+
   for (const [name, info] of Object.entries(TEMPLATES)) {
-    console.log(`  ${colors.green(name)}`);
+    const aliases = aliasesByTemplate[name];
+    const aliasSuffix = aliases ? ` ${colors.dim(`(aliases: ${aliases.join(', ')})`)}` : '';
+    console.log(`  ${colors.green(name)}${aliasSuffix}`);
     console.log(`    ${info.description}\n`);
   }
-  
+
   console.log(colors.blue('Shared rules (always included):'));
   for (const rule of SHARED_RULES) {
     console.log(`  - ${rule.replace('.md', '')}`);
@@ -1358,10 +1431,13 @@ export async function run(args) {
   }
 
   printBanner();
-  
+
   // Check for updates (non-blocking, fails silently)
   await checkForUpdates();
 
+  // Resolve template aliases to canonical names
+  const resolvedTemplates = templates.map(resolveTemplateAlias);
+
   // Use default IDEs if none specified
   const targetIdes = ides.length > 0 ? ides : DEFAULT_IDES;
 
@@ -1371,7 +1447,7 @@ export async function run(args) {
       console.error(colors.red('Error: Cannot use --remove and --reset together\n'));
       process.exit(1);
     }
-    if (templates.length > 0) {
+    if (resolvedTemplates.length > 0) {
       console.error(colors.red('Error: --reset does not accept template arguments\n'));
       console.error(colors.dim('Use --remove <templates...> to remove specific templates.\n'));
       process.exit(1);
@@ -1390,14 +1466,14 @@ export async function run(args) {
 
   // Handle remove mode
   if (removeMode) {
-    if (templates.length === 0) {
+    if (resolvedTemplates.length === 0) {
       console.error(colors.red('Error: No templates specified for removal\n'));
       console.error(colors.dim('Usage: npx cursor-templates --remove <templates...>\n'));
       printTemplates();
       process.exit(1);
     }
 
-    for (const template of templates) {
+    for (const template of resolvedTemplates) {
       if (!TEMPLATES[template]) {
         console.error(colors.red(`Error: Unknown template '${template}'\n`));
         printTemplates();
@@ -1412,18 +1488,18 @@ export async function run(args) {
       console.log(colors.yellow('FORCE MODE - Modified files will be removed\n'));
     }
 
-    await remove(process.cwd(), templates, dryRun, force, skipConfirm, targetIdes);
+    await remove(process.cwd(), resolvedTemplates, dryRun, force, skipConfirm, targetIdes);
     return;
   }
 
   // Install mode (default)
-  if (templates.length === 0) {
+  if (resolvedTemplates.length === 0) {
     console.error(colors.red('Error: No templates specified\n'));
     printHelp();
     process.exit(1);
   }
 
-  for (const template of templates) {
+  for (const template of resolvedTemplates) {
     if (!TEMPLATES[template]) {
       console.error(colors.red(`Error: Unknown template '${template}'\n`));
       printTemplates();
@@ -1440,7 +1516,7 @@ export async function run(args) {
   }
 
   // Install to current directory
-  install(process.cwd(), templates, dryRun, force, targetIdes);
+  install(process.cwd(), resolvedTemplates, dryRun, force, targetIdes);
 }
 
 // Export internals for testing
@@ -1450,11 +1526,13 @@ export const _internals = {
   REPO_URL,
   CHANGELOG_URL,
   TEMPLATES,
+  TEMPLATE_ALIASES,
   SHARED_RULES,
   SUPPORTED_IDES,
   DEFAULT_IDES,
   compareVersions,
   checkForUpdates,
+  resolveTemplateAlias,
   filesMatch,
   parseMarkdownSections,
   generateSectionSignature,

package/src/index.test.js

@@ -8,10 +8,12 @@ const {
   PACKAGE_NAME,
   CURRENT_VERSION,
   TEMPLATES,
+  TEMPLATE_ALIASES,
   SHARED_RULES,
   SUPPORTED_IDES,
   DEFAULT_IDES,
   compareVersions,
+  resolveTemplateAlias,
   filesMatch,
   parseMarkdownSections,
   generateSectionSignature,
@@ -74,13 +76,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 +94,7 @@ describe('Constants', () => {
         'python-expert',
         'qa-engineering',
         'rust-expert',
+        'swift-expert',
         'testing',
         'utility-agent',
         'web-backend',
@@ -145,6 +152,50 @@ describe('Constants', () => {
       expect(DEFAULT_IDES).toEqual(SUPPORTED_IDES);
     });
   });
+
+  describe('TEMPLATE_ALIASES', () => {
+    it('all alias values should be valid TEMPLATES keys', () => {
+      for (const [alias, canonical] of Object.entries(TEMPLATE_ALIASES)) {
+        expect(TEMPLATES).toHaveProperty(canonical,
+          expect.anything(),
+        );
+      }
+    });
+
+    it('should include expected shorthand aliases', () => {
+      expect(TEMPLATE_ALIASES['js']).toBe('javascript-expert');
+      expect(TEMPLATE_ALIASES['ts']).toBe('javascript-expert');
+      expect(TEMPLATE_ALIASES['go']).toBe('golang-expert');
+      expect(TEMPLATE_ALIASES['py']).toBe('python-expert');
+      expect(TEMPLATE_ALIASES['rs']).toBe('rust-expert');
+      expect(TEMPLATE_ALIASES['kt']).toBe('kotlin-expert');
+    });
+  });
+
+  describe('resolveTemplateAlias', () => {
+    it('should resolve known aliases to canonical names', () => {
+      expect(resolveTemplateAlias('js')).toBe('javascript-expert');
+      expect(resolveTemplateAlias('typescript')).toBe('javascript-expert');
+      expect(resolveTemplateAlias('go')).toBe('golang-expert');
+      expect(resolveTemplateAlias('golang')).toBe('golang-expert');
+      expect(resolveTemplateAlias('py')).toBe('python-expert');
+      expect(resolveTemplateAlias('rs')).toBe('rust-expert');
+      expect(resolveTemplateAlias('kotlin')).toBe('kotlin-expert');
+      expect(resolveTemplateAlias('kt')).toBe('kotlin-expert');
+    });
+
+    it('should pass through unknown names unchanged', () => {
+      expect(resolveTemplateAlias('web-frontend')).toBe('web-frontend');
+      expect(resolveTemplateAlias('blockchain')).toBe('blockchain');
+      expect(resolveTemplateAlias('nonexistent')).toBe('nonexistent');
+    });
+
+    it('should pass through canonical template names unchanged', () => {
+      expect(resolveTemplateAlias('javascript-expert')).toBe('javascript-expert');
+      expect(resolveTemplateAlias('golang-expert')).toBe('golang-expert');
+      expect(resolveTemplateAlias('python-expert')).toBe('python-expert');
+    });
+  });
 });
 
 // ============================================================================
@@ -1014,7 +1065,50 @@ describe('CLI Argument Parsing', () => {
   it('should accept -y shorthand for yes', async () => {
     await run(['web-frontend']);
     await run(['--reset', '-y']);
-    
+
+    expect(exitSpy).not.toHaveBeenCalled();
+  });
+
+  it('should resolve shorthand alias "js" to javascript-expert', async () => {
+    await run(['js', '--dry-run']);
+
+    expect(exitSpy).not.toHaveBeenCalled();
+  });
+
+  it('should resolve shorthand alias "go" to golang-expert', async () => {
+    await run(['go', '--dry-run']);
+
+    expect(exitSpy).not.toHaveBeenCalled();
+  });
+
+  it('should resolve shorthand alias "py" to python-expert', async () => {
+    await run(['py', '--dry-run']);
+
+    expect(exitSpy).not.toHaveBeenCalled();
+  });
+
+  it('should resolve shorthand alias "rs" to rust-expert', async () => {
+    await run(['rs', '--dry-run']);
+
+    expect(exitSpy).not.toHaveBeenCalled();
+  });
+
+  it('should resolve shorthand alias "kt" to kotlin-expert', async () => {
+    await run(['kt', '--dry-run']);
+
+    expect(exitSpy).not.toHaveBeenCalled();
+  });
+
+  it('should resolve aliases in --remove mode', async () => {
+    await run(['go']);
+    await run(['--remove', 'go', '--yes']);
+
+    expect(exitSpy).not.toHaveBeenCalled();
+  });
+
+  it('should still accept canonical template names', async () => {
+    await run(['javascript-expert', '--dry-run']);
+
     expect(exitSpy).not.toHaveBeenCalled();
   });
 });

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()
+```