agents-templated 1.2.0 → 1.2.2

package/README.md

@@ -1,511 +1,353 @@
-# Technology-Agnostic Development Template
+# Agents Templated
 
 [![npm version](https://img.shields.io/npm/v/agents-templated.svg)](https://www.npmjs.com/package/agents-templated)
 [![npm downloads](https://img.shields.io/npm/dm/agents-templated.svg)](https://www.npmjs.com/package/agents-templated)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![GitHub stars](https://img.shields.io/github/stars/rickandrew2/agents-projects-templated?style=social)](https://github.com/rickandrew2/agents-templated)
 
-An enterprise-grade development template that works with any technology stack. Provides proven patterns, security guidelines, and AI assistant integration for Cursor and GitHub Copilot. You choose your tech stack (React, Django, Go, etc.) and install it separately—this package scaffolds the structure and patterns you'll follow.
+> **Agents Templated** is a CLI tool and npm package that instantly scaffolds production-ready project structures with enterprise-grade development patterns, security guidelines, and AI assistant configurations. Designed for developers who want to start projects the right way—with proven OWASP security practices, comprehensive testing strategies (80/15/5 coverage targets), and agent-based architecture patterns—without being locked into specific frameworks. It generates unified configuration files that work seamlessly with Cursor, GitHub Copilot, Claude, and Google Gemini, allowing AI assistants to automatically follow best practices from day one. Whether you're building a Next.js app, Django API, Go microservice, or any custom stack, Agents Templated provides the guardrails and patterns you need while giving you complete freedom to choose your technology.
 
-## Overview
-
-This template provides proven development patterns and guidelines that work with **any** technology stack. It scaffolds project structure, AI assistant configurations, and security patterns—but does **not** install tech packages for you. After running `agents-templated init`, you independently install your chosen frameworks (React, Django, Go, etc.) into the scaffolded structure.
+---
 
-## Key Features
+## What is Agents Templated?
 
-- **Quick Start Presets** (v1.1.0): Fast-track setup with popular tech stack presets
-- **Interactive Wizard** (v1.1.0): Guided setup with personalized recommendations
-- **Project Validation** (v1.1.0): Automated checks for configuration and best practices
-- **Template Updates** (v1.1.0): Keep your templates in sync with latest improvements
-- **Technology-Agnostic**: Patterns and structure that work with any tech stack
-- **AI Assistant Ready**: Pre-configured for Cursor, GitHub Copilot, and other AI coding tools
-- **Security-First**: Built-in OWASP Top 10 protection patterns and security guidelines
-- **Testing Strategy**: Defined approach with unit, integration, and E2E coverage targets
-- **Agent-Based Architecture**: Specialized agents for frontend, backend, database, testing, security
-- **Type-Safe Development**: Validation patterns applicable to any language
-- **Accessibility Guidelines**: WCAG 2.1 AA compliance patterns built-in
+Agents Templated scaffolds your project with:
 
-## What's New in v1.1.0
+✅ **AI Agent Configurations** – Auto-discovery files for 4 major AI coding assistants  
+✅ **Security-First Patterns** – OWASP Top 10 protection guidelines built-in  
+✅ **Testing Strategy** – 80/15/5 coverage targets (unit/integration/e2e)  
+✅ **Agent-Based Architecture** – Specialized patterns for frontend, backend, database, testing, security  
+✅ **Technology-Agnostic** – Works with React, Django, Go, FastAPI, Next.js, or any stack you choose
 
-### 🚀 Quick Start Presets
-Get started instantly with pre-configured setups for popular tech stacks:
-```bash
-agents-templated init --preset=nextjs        # Next.js full-stack app
-agents-templated init --preset=express-api   # Express.js REST API
-agents-templated init --preset=django-react  # Django + React
-agents-templated init --preset=fastapi       # FastAPI backend
-agents-templated init --preset=go-api        # Go API server
-```
+**Important:** This package does **NOT** install frameworks or libraries. It scaffolds the structure, patterns, and AI configurations—you install your chosen tech stack separately.
 
-Each preset includes:
-- Recommended package lists for your tech stack
-- Stack-specific configuration templates
-- Optimized .gitignore patterns
-- Pre-configured agent rules
+---
 
-### 🧙 Interactive Setup Wizard
+## 🚀 Quick Start
 
-Guided setup experience with smart recommendations:
+### 1. Run the Interactive Wizard (Recommended)
 
 ```bash
+# Using npx (no installation needed) - RECOMMENDED
+npx agents-templated@latest wizard
+
+# Or install globally first
+npm install -g agents-templated
 agents-templated wizard
 ```
 
-**Features:**
-- Choose project type: fullstack, frontend, backend, CLI, package, or custom
-- Select frameworks and databases interactively
-- Receive personalized package recommendations
-- Install only the components you need
-- Get next-step guidance tailored to your stack
-
-### ✅ Validation & Health Checks
-
-Ensure your project follows best practices:
+**Or use a preset for fast setup:**
 
 ```bash
-agents-templated validate    # Quick validation of setup
-agents-templated doctor      # Comprehensive health check with recommendations
+# Initialize with a specific preset
+npx agents-templated@latest init --preset=nextjs        # Next.js
+npx agents-templated@latest init --preset=express-api   # Express
+npx agents-templated@latest init --preset=django-react  # Django
+npx agents-templated@latest init --preset=fastapi       # FastAPI
+npx agents-templated@latest init --preset=go-api        # Go
+
+# Or install all components without a preset
+npx agents-templated@latest init --all
 ```
 
-**Checks include:**
-- Required documentation files present
-- Agent rules properly configured
-- AI assistant configurations valid
-- Security patterns implemented
-- Testing structure in place
+### 2. Install Your Tech Stack
 
-### 🔄 Keep Templates Updated
+After initializing, install your chosen framework:
 
-Stay current with latest improvements:
+### 2. Install Your Tech Stack
+
+After initializing, install your chosen framework:
 
 ```bash
-agents-templated update              # Apply updates with backup
-agents-templated update --check-only # Check without installing
+# Frontend
+npm install next react react-dom              # Next.js
+npm install vue nuxt                          # Nuxt
+npm install @angular/core @angular/cli        # Angular
+
+# Backend
+npm install express typescript zod            # Express
+pip install django djangorestframework        # Django
+pip install fastapi uvicorn pydantic          # FastAPI
+go mod init your-project                      # Go
+
+# Database
+npm install prisma @prisma/client             # Prisma ORM
+pip install sqlalchemy alembic                # SQLAlchemy
+npm install mongoose                          # Mongoose (MongoDB)
 ```
 
-**Features:**
-- Automatic backup creation before updates
-- Preview changes before applying
-- Selective file updates
-- Preserves your customizations
-
-### 🧪 Comprehensive Testing
+### 3. Start Coding with AI
 
-All core functionality includes automated tests:
-- 10+ unit tests covering install operations
-- Jest test framework with coverage reporting
-- Tested on Windows, macOS, and Linux
-- CI/CD ready with `npm run test:ci`
+Your AI assistant will auto-load the configurations and follow enterprise patterns automatically!
 
-## 🤖 Multi-AI Agent Support (v1.2.0)
-
-**Agents Templated v1.2.0 now supports 4 major AI agents with auto-discovered configuration files:**
+---
 
-### Supported AI Agents
+## ✨ Key Features
 
-| Agent | Config File | Auto-Discovery | Best For |
-|-------|-------------|-----------------|----------|
-| **Cursor IDE** | `.cursorrules` | ✅ Auto-loaded | Full IDE with native agent support |
-| **GitHub Copilot** | `.github/copilot-instructions.md` | ✅ Auto-loaded | Code completion and generation in any editor |
-| **VSCode AI Extensions** | `.vscode-ai-rules.md` | ✅ Auto-loaded | Copilot Chat and other VSCode AI tools |
-| **Google Gemini** | `.gemini-instructions.md` | ✅ Auto-loaded | Google Gemini API and IDE plugins |
+| Feature | Description |
+|---------|-------------|
+| 🚀 **Quick Start Presets** | 5 popular tech stack presets (Next.js, Express, Django, FastAPI, Go) |
+| 🧙 **Interactive Wizard** | Guided setup with personalized recommendations |
+| 🤖 **4 AI Agents Supported** | Cursor, GitHub Copilot, Claude, Google Gemini (auto-discovery) |
+| 🔒 **Security-First** | OWASP Top 10 protection patterns built-in |
+| 🧪 **Testing Strategy** | 80/15/5 coverage targets (unit/integration/e2e) |
+| ✅ **Project Validation** | `validate` and `doctor` commands for health checks |
+| 🔄 **Template Updates** | Keep your templates in sync with `update` command |
+| 🎯 **Technology-Agnostic** | Works with React, Django, Go, FastAPI, Next.js, or any stack |
+| ♿ **Accessibility** | WCAG 2.1 AA compliance patterns included |
 
-### How It Works
+---
 
-1. **Run `npx agents-templated init`** to create all 4 config files
-2. **Each AI agent auto-discovers its config file** in the project root
-3. **All agents read from the same ruleset**: `agents/rules/` and `agents/skills/`
-4. **No duplication**: Rules and guidelines live in one place
+## 🤖 AI Agent Support
 
-### Example: Setup and Use
+Agents Templated automatically configures 4 major AI coding assistants:
 
-```bash
-# Initialize project with all 4 AI agent configs
-npx agents-templated init --preset=nextjs
+| AI Agent | Config File | Auto-Discovery |
+|----------|-------------|----------------|
+| **Cursor** | `.cursorrules` | ✅ Auto-loads in Cursor IDE |
+| **GitHub Copilot** | `.github/copilot-instructions.md` | ✅ Auto-loads in VS Code |
+| **Claude** | `CLAUDE.md` | ✅ Auto-loads in Claude IDE/API |
+| **Gemini** | `GEMINI.md` | ✅ Auto-loads in Gemini IDE/API |
 
-# Or choose components manually
-npx agents-templated init --all
+**All agents follow the same rules:** `agents/rules/` directory contains unified patterns for security, testing, code style, and architecture. No duplication, one source of truth.
 
-# Now open your project in any AI-enabled editor:
-# - Open in Cursor → .cursorrules loads automatically
-# - Open in VSCode with Copilot Chat → .vscode-ai-rules.md loads automatically
-# - Use Gemini API → .gemini-instructions.md loads automatically
-# - Use GitHub Copilot → .github/copilot-instructions.md loads automatically
-```
+---
 
-### Unified Rules System
+## 📦 What Gets Installed
 
-All 4 AI agents read from the same source of truth:
+When you run `agents-templated init`, you get:
 
 ```
-agents/
-├── rules/
-│   ├── core.mdc              # Core development principles
-│   ├── security.mdc          # Security patterns (CRITICAL)
-│   ├── testing.mdc           # Testing strategy
-│   ├── frontend.mdc          # Frontend patterns
-│   ├── database.mdc          # Database patterns
-│   └── style.mdc             # Code style guidelines
-└── skills/
-    ├── find-skills/          # Domain-specific guidance
-    └── web-design-guidelines/
-```
-
-Every AI agent, regardless of the tool, follows the same:
-- Security patterns (OWASP Top 10)
-- Testing strategy (80/15/5)
-- Code quality standards
-- Architecture principles
-
-### Adding New Agents in the Future
-
-Future v1.3+ can add more agents by simply creating new config files that point to the same `agents/rules/` directory. The unified architecture makes this trivial—no duplicate rules needed.
-
-## 🚀 Quick Start
-
-### Installation
-
-**Global Installation (Recommended)**
-
-```bash
-npm install -g agents-templated
-cd your-project
-agents-templated init --preset=nextjs  # or use wizard
+your-project/
+├── agent-docs/                      # 📚 Comprehensive documentation
+│   ├── AI_INSTRUCTIONS.md          # Primary AI assistant guide
+│   ├── ARCHITECTURE.md             # Project architecture & tech stack
+│   ├── AGENTS.MD                   # Agent delegation patterns
+│   └── README.md                   # Human-readable setup guide
+│
+├── agents/                          # 🤖 AI Agent rules and skills
+│   ├── rules/
+│   │   ├── core.mdc               # Core development principles
+│   │   ├── security.mdc           # Security patterns (CRITICAL)
+│   │   ├── testing.mdc            # Testing strategy
+│   │   ├── frontend.mdc           # Frontend patterns
+│   │   ├── database.mdc           # Database patterns
+│   │   └── style.mdc              # Code style guidelines
+│   └── skills/
+│       ├── web-design-guidelines/ # UI/UX patterns
+│       └── find-skills/           # Skill discovery
+│
+├── .github/
+│   └── copilot-instructions.md    # GitHub Copilot config
+│
+├── CLAUDE.md                       # Claude AI config
+├── GEMINI.md                       # Gemini AI config
+├── .cursorrules                    # Cursor IDE config
+├── .gitignore                      # Pre-configured Git ignore
+└── README.md                       # Project documentation
 ```
 
-**Local Installation (Per Project)**
+---
 
-```bash
-npm install --save-dev agents-templated
-npx agents-templated init --preset=nextjs
-```
+## 📋 Command Reference
 
-**Using npx (No Installation)**
+### Setup Commands
 
 ```bash
-cd your-project
-npx agents-templated@latest init --preset=nextjs
-```
-
-### 📋 CLI Commands
+# 🧙 Interactive wizard (recommended for beginners)
+agents-templated wizard
 
-**Setup Commands:**
-```bash
-# Quick start with presets
+# 🚀 Quick start with presets
 agents-templated init --preset=nextjs         # Next.js full-stack
-agents-templated init --preset=django-react   # Django + React
 agents-templated init --preset=express-api    # Express.js API
+agents-templated init --preset=django-react   # Django + React
 agents-templated init --preset=fastapi        # FastAPI
 agents-templated init --preset=go-api         # Go API
 
-# Interactive wizard
-agents-templated wizard                       # Guided setup
-
-# Manual component selection
+# 🔧 Manual component selection
 agents-templated init --all                   # All components
 agents-templated init --docs                  # Documentation only
 agents-templated init --rules                 # Agent rules only
 agents-templated init --skills                # Skills only
-agents-templated init --github                # GitHub Copilot config
 
-# Force overwrite
-agents-templated init --all --force           # Overwrite existing files
+# ⚠️ Force overwrite existing files
+agents-templated init --all --force
 ```
 
-**Maintenance Commands:**
+### Maintenance Commands
+
 ```bash
-# Validation
-agents-templated validate                     # Quick setup validation
+# ✅ Validate your project setup
+agents-templated validate                     # Quick validation
 agents-templated doctor                       # Comprehensive health check
 
-# Updates
-agents-templated update                       # Apply template updates
+# 🔄 Update templates to latest version
+agents-templated update                       # Apply updates with backup
 agents-templated update --check-only          # Check without installing
 
-# Information
-agents-templated list                         # Show components and presets
+# 📚 List available components and presets
+agents-templated list
 ```
 
-### Install Your Technology Stack
-
-After initializing the template, install your chosen framework and dependencies. The template provides patterns but does **not** install packages for you.
+---
 
-**Frontend:**
-- React/Next.js, Vue/Nuxt, Angular, Svelte/SvelteKit, or traditional SSR
+## 🎯 After Installation: Next Steps
 
-**Backend:**
-- Node.js (Express/Fastify/Nest.js), Python (Django/FastAPI/Flask), Go, Rust, Java/Spring Boot, Ruby on Rails, PHP (Laravel)
+### 1. Install Your Tech Stack
 
-**Database:**
-- PostgreSQL, MySQL, MongoDB, SQLite, or cloud solutions (Supabase, Firebase, PlanetScale)
+After initializing, install your chosen framework:
 
-**Example installations:**
 ```bash
-# Next.js
-npm install next react react-dom typescript
-
-# Django
-pip install django djangorestframework python-dotenv
-
-# Express API
-npm install express typescript zod prisma
+# Frontend
+npm install next react react-dom              # Next.js
+npm install vue nuxt                          # Nuxt
+npm install @angular/core @angular/cli        # Angular
+
+# Backend
+npm install express typescript zod            # Express
+pip install django djangorestframework        # Django
+pip install fastapi uvicorn pydantic          # FastAPI
+go mod init your-project                      # Go
+
+# Database
+npm install prisma @prisma/client             # Prisma ORM
+pip install sqlalchemy alembic                # SQLAlchemy
+npm install mongoose                          # Mongoose (MongoDB)
 ```
 
-### 🤖 Configure AI Assistants
+### 2. Review AI Configuration Files
 
-The template includes configuration files for multiple AI coding assistants:
+Open your AI assistant and it will automatically load the appropriate config:
 
-**Cursor:**
-- Auto-loads `.cursorrules` and `agents/rules/*.mdc` files
-- No additional configuration needed
+- **Cursor**: Opens `.cursorrules` automatically
+- **GitHub Copilot**: Reads `.github/copilot-instructions.md`
+- **Claude**: Reads `CLAUDE.md`
+- **Gemini**: Reads `GEMINI.md`
 
-**GitHub Copilot:**
-- Auto-loads `.github/copilot-instructions.md`
-- Works in VS Code,VS Code Insiders, and github.com
+### 3. Read the Documentation
 
-**Other AI Tools:**
-- Reference `AI_INSTRUCTIONS.md` explicitly in your prompts
-- Copy relevant rules from `agents/rules/` as needed
+- **[agent-docs/AI_INSTRUCTIONS.md](agent-docs/AI_INSTRUCTIONS.md)** – Primary AI assistant guide
+- **[agent-docs/ARCHITECTURE.md](agent-docs/ARCHITECTURE.md)** – Project architecture & tech stack guidance
+- **[agent-docs/AGENTS.MD](agent-docs/AGENTS.MD)** – Agent delegation patterns
+- **[agents/rules/security.mdc](agents/rules/security.mdc)** – Security patterns (CRITICAL)
+- **[agents/rules/testing.mdc](agents/rules/testing.mdc)** – Testing strategy
 
-## \ud83d\udce6 What Gets Installed
+### 4. Start Building
 
-When you run `agents-templated init`, you get:
+Tell your AI assistant what to build:
 
 ```
-├── agents/                          # Agent rules and skills
-│   ├── rules/                      # Development rules and patterns
-│   │   ├── core.mdc               # Core architecture guidelines
-│   │   ├── security.mdc           # Security patterns and requirements
-│   │   ├── testing.mdc            # Testing strategy and patterns
-│   │   ├── frontend.mdc           # Frontend development patterns
-│   │   ├── database.mdc           # Database design and patterns
-│   │   └── style.mdc              # Code style and formatting rules
-│   └── skills/                     # Reusable agent skills
-│       ├── web-design-guidelines/  # Web interface guidelines skill
-│       └── find-skills/           # Skill discovery utilities
-├── .github/
-│   └── copilot-instructions.md    # GitHub Copilot configuration
-├── AGENTS.md                       # Agent responsibilities and usage guide
-├── CLAUDE.md                       # Project guidelines and architecture
-├── AI_INSTRUCTIONS.md              # Universal AI assistant instructions
-├── .gitignore                      # Pre-configured Git ignore patterns
-└── README.md                       # Project documentation
+"Create a user registration endpoint with email validation and rate limiting"
+"Build a responsive dashboard component with dark mode support"
+"Design a PostgreSQL schema for a blog with users, posts, and comments"
 ```
 
-## \ud83d\udce6 Programmatic API
-
-Use agents-templated programmatically in build scripts or automation:
-
-```javascript
-const agentsTemplated = require('agents-templated');
+Your AI will follow the enterprise patterns automatically!
 
-// Install all components
-await agentsTemplated.install('./my-project', {
-  force: true
-});
-
-// Install specific components
-await agentsTemplated.install('./my-project', {
-  docs: true,
-  rules: true,
-  skills: false,
-  github: true,
-  force: false
-});
-```
-
-## \ud83d\udcda Core Configuration Files
-\ud83e\udd16 Agent-Based Development
-
-This template uses specialized agents for different aspects of development:
-
-**FrontendAgent:**\nHandles UI/UX development, component creation, design system implementation, and accessibility compliance.
-
-**BackendAgent:**\nManages API development, business logic, authentication, authorization, rate limiting, and security middleware.
+---
 
-**DatabaseAgent:**\nOwns database schema design, migrations, query optimization, and data access patterns.
+## 🏗️ Core Principles
 
-**TestAgent:**\nImplements comprehensive testing strategy across unit, integration, E2E, accessibility, and security testing.
+### Security-First Development
 
-**SecurityAgent:**\nEnsures security-first development with input validation, authentication patterns, authorization checks, and OWASP compliance.
+✅ Validate all inputs at application boundaries with schema validation  
+✅ Authenticate and authorize every protected endpoint  
+✅ Rate limit public endpoints to prevent abuse  
+✅ Sanitize outputs to prevent injection attacks  
+✅ Never expose sensitive data in error messages or logs
 
-**ReviewerAgent:**\nPerforms code reviews focusing on correctness, security, performance, test coverage, and accessibility.
+**Reference**: [agents/rules/security.mdc](agents/rules/security.mdc)
 
-## \ud83d\udd12 Agent-Based Development
+### Testing Strategy
 
-This template uses specialized agents for different aspects of development:
+- **80% Unit Tests** – Business logic, pure functions, utilities
+- **15% Integration Tests** – API endpoints, database operations
+- **5% E2E Tests** – Critical user journeys
 
-### FrontendAgent
-Handles UI/UX development, component creation, design system implementation, and accessibility compliance.
+**Reference**: [agents/rules/testing.mdc](agents/rules/testing.mdc)
 
-### BackendAgent
-Manages API development, business logic, authentication, authorization, rate limiting, and security middleware.
+### Agent-Based Architecture
 
-### DatabaseAgent
-Owns database schema design, migrations, query optimization, and data access patterns.
+| Agent | Responsibility |
+|-------|---------------|
+| **FrontendAgent** | UI/UX, components, design system, accessibility |
+| **BackendAgent** | API, business logic, authentication, middleware |
+| **DatabaseAgent** | Schema design, migrations, query optimization |
+| **TestAgent** | Unit, integration, E2E, accessibility testing |
+| **SecurityAgent** | Input validation, authentication, OWASP compliance |
 
-### TestAgent
-Implements comprehensive testing strategy across unit, integration, E2E, accessibility, and security testing.
+**Reference**: [agent-docs/AGENTS.MD](agent-docs/AGENTS.MD)
 
-### SecurityAgent
-Ensures security-first development with input validation, authentication patterns, authorization checks, and OWASP compliance.
+---
 
-### ReviewerAgent
-Performs code reviews focusing on correctness, security, performance, test coverage, and accessibility.
+## 📚 Available Presets
 
-## Core Principles
+| Preset | Tech Stack | Best For |
+|--------|-----------|----------|
+| `nextjs` | Next.js + React + TypeScript | Full-stack web applications |
+| `express-api` | Express + TypeScript + Zod | REST APIs and microservices |
+| `django-react` | Django + React + PostgreSQL | Full-stack with Python backend |
+| `fastapi` | FastAPI + Pydantic + SQLAlchemy | High-performance Python APIs |
+| `go-api` | Go + Gin/Echo + PostgreSQL | Scalable Go microservices |
 
-### Security-First Development
-- Validate all inputs at application boundaries with schema validation
-- Authenticate and authorize every protected endpoint
-- Rate limit public endpoints to prevent abuse
-- Sanitize outputs to prevent injection attacks
-- Never expose sensitive data in error messages or logs
-
-### Testing Strategy
-- **Unit Tests**: 80% coverage for business logic
-- **Integration Tests**: 15% coverage for API endpoints and database operations
-- **E2E Tests**: 5% coverage for critical user journeys
-- **Accessibility Tests**: WCAG 2.1 AA compliance for all UI
-
-### Type Safety
-- Use strong typing systems available in your chosen language
-- Implement runtime validation for all external/user-provided data
-- Validate at boundaries: API endpoints, form submissions, configuration
-- Generate types from schemas when possible (OpenAPI, GraphQL, database schemas)
-
-### Code Quality
-- Maintain consistent patterns throughout the codebase
-- Follow established code style guidelines
-- Ensure proper error handling and logging
-- Keep documentation updated with code changes
-
-## Security Patterns
-
-### Input Validation Example
-
-```typescript
-// TypeScript with Zod
-imp\ud83d\udd12 ort { z } from 'zod'
-
-const userSchema = z.object({
-  email: z.string().email().toLowerCase(),
-  password: z.string().min(8)
-})
-```
+Each preset includes:
+- Recommended package list
+- Stack-specific configurations
+- Optimized `.gitignore` patterns
+- Pre-configured agent rules
 
-```python
-# Python with Pydantic
-from pydantic import BaseModel, EmailStr
+---
 
-class User(BaseModel):
-    email: EmailStr
-    password: str
-```
+## 🔧 Programmatic API
 
-### Rate Limiting Example
+Use agents-templated in your build scripts or automation:
 
 ```javascript
-// Node.js with express-rate-limit
-const rateLimit = require('express-rate-limit')
-
-const authLimiter = rateLimit({
-  windowMs: 15 * 60 * 1000, // 15 minutes
-  max: 5, // 5 attempts per window
-  message: 'Too many authentication attempts'
-})
-```
-
-## Testing Strategy
-
-### Coverage Targets
-- **Unit Tests**: 80% coverage for business logic
-- **Integration Tests**: 15% coverage for API endpoints and database operations
-- **E2E Tests**: 5% coverage for critical user journeys
-\ud83e\uddea 
-### Testing Tools by Technology
-
-**JavaScript/TypeScript:**
-- Unit/Integration: Jest, Vitest, or framework-specific test runners
-- E2E: Playwright, Cypress, or Selenium
-- Component: Testing Library, Enzyme
-
-**Python:**
-- Unit/Integration: pytest, unittest
-- E2E: Selenium, Playwright
-- API: requests, httpx
-
-**Go:**
-- Unit/Integration: Built-in testing package, testify
-- E2E: Selenium, Playwright
-- HTTP: httptest package
-
-## AI Assistant Integration
+const agentsTemplated = require('agents-templated');
 
-### Cursor
-Rules are automatically loaded from:
-- `.cursorrules` file
-- `agents/rules/*.mdc` files with `alwaysApply: true`
-- `\ud83e\udd16 AGENTS.md` and `CLAUDE.md` (via workspace rules)
+// Install all components
+await agentsTemplated.install('./my-project', {
+  force: true
+});
 
-### GitHub Copilot
-Instructions are automatically loaded from:
-- `.github/copilot-instructions.md`
+// Install specific components
+await agentsTemplated.install('./my-project', {
+  docs: true,
+  rules: true,
+  skills: false,
+  github: true,
+  force: false
+});
+```
 
-### Other AI Assistants
-Reference `AI_INSTRUCTIONS.md` explicitly in your prompts:
-- "Follow the patterns in `AI_INSTRUCTIONS.md`"
-- "Check `AGENTS.md` for agent delegation"
-- "Apply security patterns from `agents/rules/security.mdc`"
+---
 
-## \ud83d\udcdd Usage Examples
+## 📝 Usage Examples
 
 ### Frontend Development
 ```
 "Create a responsive navigation component with accessibility support"
-"Redesign the user profile page following our design system"
-"Implement the login form with proper validation"
+"Implement dark mode toggle with user preference persistence"
+"Build a data table with sorting, filtering, and pagination"
 ```
 
 ### Backend Development
 ```
-"Create a secure user registration endpoint with rate limiting"
-"Implement JWT authentication middleware"
+"Create a secure user registration endpoint with email validation and rate limiting"
+"Implement JWT authentication middleware with refresh tokens"
 "Add password reset functionality with email verification"
 ```
 
 ### Database Operations
 ```
-"Design a user roles and permissions schema"
-"Create a migration to add audit logging"
-"Optimize the user query to prevent N+1 problems"
+"Design a user roles and permissions schema with PostgreSQL"
+"Create a migration to add full-text search to the posts table"
+"Optimize the user query to prevent N+1 problems using joins"
 ```
 
-## Documentation
-
-### Getting Started
-1. Review `CLAUDE.md` for architecture and technology selection guidance
-2. Check `AGENTS.md` for agent responsibilities and delegation patterns
-3. Reference `agents/rules/*.mdc` files for detailed implementation patterns
-4. Configure your AI assistant using the appropriate configuration file
-
-### Additional Resources
-- **Architecture**: See `CLAUDE.md` for detailed architecture guidelines
-- **Agent Usage**: See `AGENTS.md` for detailed agent responsibilities
-- **Security**: See `agents/rules/security.mdc` for security patterns
-- **Testing**: See `agents/rules/testing.mdc` for testing strategy
-- **Code Style**: See `agents/rules/style.mdc` for formatting rules
-
-## Quality Gates
-
-All code must meet these standards:
-- Pass linting and formatting checks
-- Meet minimum test coverage thresholds (80% unit, 15% integration, 5% E2E)
-- Pass security scans without high-severity issues
-- Pass accessibility tests for user-facing features
-- Follow established patterns and conventions
+---
 
-## Contributing
+## 🤝 Contributing
 
 When contributing to this template:
 1. Maintain technology-agnostic patterns
@@ -514,6 +356,27 @@ When contributing to this template:
 4. Follow security and testing patterns
 5. Ensure AI assistant configurations remain compatible
 
+See [CONTRIBUTING.md](CONTRIBUTING.md) for detailed guidelines.
+
+---
+
+## 📖 License
+
+MIT License - See [LICENSE](LICENSE) for details.
+
 ---
 
-**Ready to start building?** Choose your technology stack, adapt the configuration files, and begin development with enterprise-grade patterns from day one.
+## 🔗 Links
+
+- **NPM Package**: https://www.npmjs.com/package/agents-templated
+- **GitHub Repository**: https://github.com/rickandrew2/agents-templated
+- **Issues & Bug Reports**: https://github.com/rickandrew2/agents-templated/issues
+- **Changelog**: [CHANGELOG.md](CHANGELOG.md)
+
+---
+
+**Ready to start building?** Choose your technology stack and begin development with enterprise-grade patterns from day one!
+
+```bash
+npx agents-templated@latest wizard
+```