agents-templated 1.1.1 → 1.2.0

package/README.md

@@ -13,17 +13,17 @@ This template provides proven development patterns and guidelines that work with
 
 ## Key Features
 
-- **⚡ Quick Start Presets** (NEW in v1.1.0): Fast-track setup with popular tech stack presets
-- **🧙 Interactive Wizard** (NEW in v1.1.0): Guided setup with personalized recommendations
-- **✅ Project Validation** (NEW in v1.1.0): Automated checks for configuration and best practices
-- **🔄 Template Updates** (NEW in v1.1.0): Keep your templates in sync with latest improvements
-- **Technology-Agnostic Templates**: Provides patterns and structure that work with any tech stack
-- **AI Assistant Ready**: Pre-configured instructions for Cursor, GitHub Copilot, and other AI coding tools
-- **Security-First Patterns**: Built-in OWASP Top 10 protection patterns and security guidelines
-- **Testing Strategy**: Defined testing approach with unit, integration, and E2E coverage targets
-- **Agent-Based Architecture**: Guides for specialized agents (frontend, backend, database, testing, security)
-- **Type-Safe Development**: Type validation patterns applicable to any language
-- **Accessibility Guidelines**: WCAG 2.1 AA compliance patterns built into development guides
+- **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
 
 ## What's New in v1.1.0
 
@@ -38,175 +38,236 @@ agents-templated init --preset=go-api        # Go API server
 ```
 
 Each preset includes:
-- Recommended package lists
-- Tech stack-specific configuration
+- Recommended package lists for your tech stack
+- Stack-specific configuration templates
 - Optimized .gitignore patterns
-- Customized agent rules
+- Pre-configured agent rules
 
 ### 🧙 Interactive Setup Wizard
-New guided setup experience:
+
+Guided setup experience with smart recommendations:
+
 ```bash
 agents-templated wizard
 ```
-- Choose your project type (fullstack, frontend, backend, etc.)
-- Select frameworks and databases
-- Get personalized package recommendations
-- Install only what you need
+
+**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:
+
 ```bash
 agents-templated validate    # Quick validation of setup
-agents-templated doctor      # Comprehensive health check
+agents-templated doctor      # Comprehensive health check with recommendations
 ```
 
+**Checks include:**
+- Required documentation files present
+- Agent rules properly configured
+- AI assistant configurations valid
+- Security patterns implemented
+- Testing structure in place
+
 ### 🔄 Keep Templates Updated
+
 Stay current with latest improvements:
+
 ```bash
-agents-templated update              # Apply updates
+agents-templated update              # Apply updates with backup
 agents-templated update --check-only # Check without installing
 ```
 
+**Features:**
+- Automatic backup creation before updates
+- Preview changes before applying
+- Selective file updates
+- Preserves your customizations
+
 ### 🧪 Comprehensive Testing
-All features now include automated tests with Jest for reliability.
 
-## Quick Start
+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`
+
+## 🤖 Multi-AI Agent Support (v1.2.0)
 
-### Installation Options
+**Agents Templated v1.2.0 now supports 4 major AI agents with auto-discovered configuration files:**
 
-**Option 1: NPM Package (Recommended for Existing Projects)**
+### Supported AI Agents
 
-Install globally and use in any project:
+| 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 |
+
+### 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
+
+### Example: Setup and Use
 
 ```bash
-# Install globally
-npm install -g agents-templated
+# Initialize project with all 4 AI agent configs
+npx agents-templated init --preset=nextjs
+
+# Or choose components manually
+npx agents-templated init --all
+
+# 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
+
+All 4 AI agents read from the same source of truth:
+
+```
+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.
 
-# Use in any existing project
-cd your-existing-project
-agents-templated init
+## 🚀 Quick Start
+
+### Installation
+
+**Global Installation (Recommended)**
+
+```bash
+npm install -g agents-templated
+cd your-project
+agents-templated init --preset=nextjs  # or use wizard
 ```
 
-Or install locally per project:
+**Local Installation (Per Project)**
 
 ```bash
-# Install as dev dependency
 npm install --save-dev agents-templated
-
-# Initialize templates
-npx agents-templated init
+npx agents-templated init --preset=nextjs
 ```
 
-**Option 2: Clone Template (New Projects)**
+**Using npx (No Installation)**
 
 ```bash
-git clone <this-repo> my-project
-cd my-project
+cd your-project
+npx agents-templated@latest init --preset=nextjs
 ```
 
-### CLI Usage
+### 📋 CLI Commands
 
+**Setup Commands:**
 ```bash
-# Quick start with presets (NEW in v1.1.0)
+# 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=fastapi        # FastAPI
 agents-templated init --preset=go-api         # Go API
 
-# Interactive setup wizard (NEW in v1.1.0)
-agents-templated wizard
-
-# Install all components
-agents-templated init --all
+# Interactive wizard
+agents-templated wizard                       # Guided setup
 
-# Install specific 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
+# 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 existing files
-agents-templated init --all --force
+# Force overwrite
+agents-templated init --all --force           # Overwrite existing files
+```
 
-# Project validation (NEW in v1.1.0)
-agents-templated validate           # Check setup and configuration
-agents-templated doctor             # Comprehensive health check
+**Maintenance Commands:**
+```bash
+# Validation
+agents-templated validate                     # Quick setup validation
+agents-templated doctor                       # Comprehensive health check
 
-# Update templates (NEW in v1.1.0)
-agents-templated update             # Apply template updates
-agents-templated update --check-only # Check for updates only
+# Updates
+agents-templated update                       # Apply template updates
+agents-templated update --check-only          # Check without installing
 
-# List available components and presets
-agents-templated list
+# Information
+agents-templated list                         # Show components and presets
 ```
 
-### Step 2: Choose Your Technology Stack
+### Install Your Technology Stack
 
-After running `agents-templated init`, select and install your preferred technologies. The template works with **any** modern stack:
+After initializing the template, install your chosen framework and dependencies. The template provides patterns but does **not** install packages for you.
 
-**Frontend Options:**
+**Frontend:**
 - React/Next.js, Vue/Nuxt, Angular, Svelte/SvelteKit, or traditional SSR
 
-**Backend Options:**
-- Node.js (Express/Fastify), Python (Django/FastAPI), Go, Rust, Java/Spring
-
-**Database Options:**
-- PostgreSQL/MySQL with ORM, MongoDB/NoSQL, or cloud solutions like Supabase
-
-**Note:** You must install these packages yourself—the template doesn't include them.
-
-### Configure AI Assistants
-
-The template includes configuration files for multiple AI assistants:
-
-- **Cursor**: Uses `.cursorrules` and `agents/rules/*.mdc` files (auto-loaded)
-- **GitHub Copilot**: Uses `.github/copilot-instructions.md` (auto-loaded)
-- **Other AI Tools**: Reference `AI_INSTRUCTIONS.md` in your prompts
+**Backend:**
+- Node.js (Express/Fastify/Nest.js), Python (Django/FastAPI/Flask), Go, Rust, Java/Spring Boot, Ruby on Rails, PHP (Laravel)
 
-### Step 3: Install Your Technology Stack
-
-Once the template is initialized, install your chosen framework and dependencies:
+**Database:**
+- PostgreSQL, MySQL, MongoDB, SQLite, or cloud solutions (Supabase, Firebase, PlanetScale)
 
+**Example installations:**
 ```bash
-# Example for Node.js + React
-npm init -y
-npm install react next typescript
+# Next.js
+npm install next react react-dom typescript
 
-# Example for Python + Django
-pip install django djangorestframework
-django-admin startproject myproject .
+# Django
+pip install django djangorestframework python-dotenv
 
-# Example for Go + Gin
-go mod init myproject
-go get github.com/gin-gonic/gin
+# Express API
+npm install express typescript zod prisma
 ```
 
-**Important:** `agents-templated init` only provides templates and patterns. You must install framework packages separately using npm, pip, go, or your tech stack's package manager.
+### 🤖 Configure AI Assistants
 
-## Programmatic API
+The template includes configuration files for multiple AI coding assistants:
 
-Use agents-templated programmatically in your build scripts:
+**Cursor:**
+- Auto-loads `.cursorrules` and `agents/rules/*.mdc` files
+- No additional configuration needed
 
-```javascript
-const agentsTemplated = require('agents-templated');
-
-// Install all components
-await agentsTemplated.install('./my-project', {
-  force: true
-});
+**GitHub Copilot:**
+- Auto-loads `.github/copilot-instructions.md`
+- Works in VS Code,VS Code Insiders, and github.com
 
-// Install specific components
-await agentsTemplated.install('./my-project', {
-  docs: true,
-  rules: true,
-  skills: false,
-  github: true,
-  force: false
-});
-```
+**Other AI Tools:**
+- Reference `AI_INSTRUCTIONS.md` explicitly in your prompts
+- Copy relevant rules from `agents/rules/` as needed
 
-## What Gets Installed
+## \ud83d\udce6 What Gets Installed
 
 When you run `agents-templated init`, you get:
 
@@ -231,30 +292,46 @@ When you run `agents-templated init`, you get:
 └── README.md                       # Project documentation
 ```
 
-## Core Configuration Files
+## \ud83d\udce6 Programmatic API
+
+Use agents-templated programmatically in build scripts or automation:
+
+```javascript
+const agentsTemplated = require('agents-templated');
+
+// 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
 
-### Documentation Files
+This template uses specialized agents for different aspects of development:
 
-- **`CLAUDE.md`** - Overall project guidelines, architecture principles, and technology stack selection
-- **`AGENTS.md`** - Agent delegation patterns, responsibilities, and when to use each agent
-- **`AI_INSTRUCTIONS.md`** - Universal instructions for any AI assistant (reference explicitly)
+**FrontendAgent:**\nHandles UI/UX development, component creation, design system implementation, and accessibility compliance.
 
-### AI Assistant Configuration
+**BackendAgent:**\nManages API development, business logic, authentication, authorization, rate limiting, and security middleware.
 
-- **`.cursorrules`** - Cursor-specific rules (auto-loaded by Cursor)
-- **`.github/copilot-instructions.md`** - GitHub Copilot instructions (auto-loaded)
-- **`agents/rules/*.mdc`** - Detailed rules with `alwaysApply: true` for auto-loading in Cursor
+**DatabaseAgent:**\nOwns database schema design, migrations, query optimization, and data access patterns.
 
-### Rule Files
+**TestAgent:**\nImplements comprehensive testing strategy across unit, integration, E2E, accessibility, and security testing.
 
-- **`agents/rules/core.mdc`** - Core architecture principles and best practices
-- **`agents/rules/security.mdc`** - Security patterns, OWASP Top 10 protection
-- **`agents/rules/testing.mdc`** - Testing strategy, coverage targets, patterns
-- **`agents/rules/frontend.mdc`** - Frontend development patterns and accessibility
-- **`agents/rules/database.mdc`** - Database schema design and query optimization
-- **`agents/rules/style.mdc`** - Code style guidelines and formatting rules
+**SecurityAgent:**\nEnsures security-first development with input validation, authentication patterns, authorization checks, and OWASP compliance.
 
-## Agent-Based Development
+**ReviewerAgent:**\nPerforms code reviews focusing on correctness, security, performance, test coverage, and accessibility.
+
+## \ud83d\udd12 Agent-Based Development
 
 This template uses specialized agents for different aspects of development:
 
@@ -309,7 +386,7 @@ Performs code reviews focusing on correctness, security, performance, test cover
 
 ```typescript
 // TypeScript with Zod
-import { z } from 'zod'
+imp\ud83d\udd12 ort { z } from 'zod'
 
 const userSchema = z.object({
   email: z.string().email().toLowerCase(),
@@ -345,7 +422,7 @@ const authLimiter = rateLimit({
 - **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:**
@@ -369,7 +446,7 @@ const authLimiter = rateLimit({
 Rules are automatically loaded from:
 - `.cursorrules` file
 - `agents/rules/*.mdc` files with `alwaysApply: true`
-- `AGENTS.md` and `CLAUDE.md` (via workspace rules)
+- `\ud83e\udd16 AGENTS.md` and `CLAUDE.md` (via workspace rules)
 
 ### GitHub Copilot
 Instructions are automatically loaded from:
@@ -381,7 +458,7 @@ Reference `AI_INSTRUCTIONS.md` explicitly in your prompts:
 - "Check `AGENTS.md` for agent delegation"
 - "Apply security patterns from `agents/rules/security.mdc`"
 
-## Usage Examples
+## \ud83d\udcdd Usage Examples
 
 ### Frontend Development
 ```

package/bin/cli.js

@@ -25,8 +25,8 @@ const program = new Command();
 
 program
   .name('agents-templated')
-  .description('Technology-agnostic development template with AI assistant integration')
-  .version('1.1.1');
+  .description('Technology-agnostic development template with multi-AI agent support')
+  .version('1.2.0');
 
 program
   .command('init')
@@ -105,7 +105,7 @@ program
               { name: 'Documentation files (AGENTS.MD, CLAUDE.md, etc.)', value: 'docs' },
               { name: 'Agent rules (agents/rules/*.mdc)', value: 'rules' },
               { name: 'Skills (agents/skills/*)', value: 'skills' },
-              { name: 'GitHub Copilot instructions', value: 'github' }
+              { name: 'AI Agent instructions (Cursor, Copilot, VSCode, Gemini)', value: 'github' }
             ],
             default: ['all']
           },
@@ -164,13 +164,20 @@ program
         );
       }
 
-      // Install GitHub Copilot instructions
+      // Install AI Agent instructions (Cursor, Copilot, VSCode, Gemini)
       if (installAll || choices.includes('github')) {
-        console.log(chalk.yellow('Installing GitHub Copilot instructions...'));
+        console.log(chalk.yellow('Installing AI agent instructions...'));
         await fs.ensureDir(path.join(targetDir, '.github'));
         await copyFiles(templateDir, targetDir, [
-          '.github/copilot-instructions.md'
+          '.cursorrules',
+          '.github/copilot-instructions.md',
+          '.vscode-ai-rules.md',
+          '.gemini-instructions.md'
         ], options.force);
+        console.log(chalk.gray('  ✓ Cursor (.cursorrules)'));
+        console.log(chalk.gray('  ✓ GitHub Copilot (.github/copilot-instructions.md)'));
+        console.log(chalk.gray('  ✓ VSCode (.vscode-ai-rules.md)'));
+        console.log(chalk.gray('  ✓ Google Gemini (.gemini-instructions.md)'));
       }
 
       console.log(chalk.green.bold('\nInstallation complete!\n'));

package/index.js

@@ -68,14 +68,32 @@ async function install(targetDir, options = {}) {
     );
   }
 
-  // GitHub Copilot instructions
+  // AI Agent instructions (Cursor, Copilot, VSCode, Gemini)
   if (installAll || options.github) {
     await fs.ensureDir(path.join(targetDir, '.github'));
-    const sourcePath = path.join(templateDir, '.github', 'copilot-instructions.md');
-    const targetPath = path.join(targetDir, '.github', 'copilot-instructions.md');
     
-    if (await fs.pathExists(sourcePath)) {
-      await fs.copy(sourcePath, targetPath, { overwrite: options.force });
+    // Copy all AI agent config files
+    const agentConfigs = [
+      '.cursorrules',
+      '.vscode-ai-rules.md',
+      '.gemini-instructions.md'
+    ];
+    
+    for (const config of agentConfigs) {
+      const sourcePath = path.join(templateDir, config);
+      const targetPath = path.join(targetDir, config);
+      
+      if (await fs.pathExists(sourcePath)) {
+        await fs.copy(sourcePath, targetPath, { overwrite: options.force });
+      }
+    }
+    
+    // Copy GitHub Copilot instructions
+    const sourceGithubPath = path.join(templateDir, '.github', 'copilot-instructions.md');
+    const targetGithubPath = path.join(targetDir, '.github', 'copilot-instructions.md');
+    
+    if (await fs.pathExists(sourceGithubPath)) {
+      await fs.copy(sourceGithubPath, targetGithubPath, { overwrite: options.force });
     }
   }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "agents-templated",
-  "version": "1.1.1",
-  "description": "Technology-agnostic development template with AI assistant integration, security-first patterns, and comprehensive testing guidelines",
+  "version": "1.2.0",
+  "description": "Technology-agnostic development template with multi-AI agent support (Cursor, Copilot, VSCode, Gemini), security-first patterns, and comprehensive testing guidelines",
   "main": "index.js",
   "bin": {
     "agents-templated": "bin/cli.js"

package/templates/.cursorrules

@@ -0,0 +1,70 @@
+# Cursor Rules - Technology-Agnostic Development Template
+# This is a flexible development template that adapts to any technology stack with enterprise-grade patterns.
+# Detailed rules are in agents/rules/*.mdc files - refer to those for implementation patterns.
+
+## Developer Identity & Communication
+- AI assistant should provide clear, step-by-step solutions with actionable examples
+- Focus on security, performance, and maintainability in all recommendations
+- Adapt patterns to the chosen technology stack
+
+## Core Principles
+- **Security-first development**: Always validate inputs, authenticate users, implement appropriate rate limiting
+- **Type safety**: Use strong typing systems available in chosen language/framework
+- **Performance optimization**: Monitor resource usage, implement caching, optimize assets
+- **Testing strategy**: Comprehensive testing at unit, integration, and E2E levels
+- **Accessibility**: WCAG 2.1 AA compliance for all user-facing interfaces
+- **Documentation**: Keep project documentation updated and comprehensive
+
+## Architecture Principles
+- **Technology-agnostic**: This template adapts to your chosen stack
+- **Security patterns**: Input validation, authentication, authorization, rate limiting
+- **Performance patterns**: Caching, lazy loading, bundle optimization
+- **Testing patterns**: Unit (80%), Integration (15%), E2E (5%) coverage target
+- **Feature-oriented structure**: Group by domain/feature, not just technical layer
+
+## Security Requirements (CRITICAL)
+- **Input validation**: All user inputs MUST be validated with appropriate schema validation
+- **Authentication**: Implement secure authentication flows with session management
+- **Rate limiting**: Public endpoints MUST have rate limiting protection
+- **Authorization**: Role-based access control with proper middleware
+- **Error handling**: Never expose sensitive data in error responses
+- **Database access**: Use ORM/ODM patterns, avoid raw queries unless performance-critical
+
+## Code Quality Standards
+- **Type Safety**: Use strict typing, avoid loose type usage
+- **Performance**: Monitor bundle/binary size, implement lazy loading patterns
+- **Accessibility**: WCAG 2.1 AA compliance for user-facing components
+- **Testing**: All business logic and user flows must have appropriate tests
+- **Documentation**: Keep README, CLAUDE.md, and AGENTS.md updated
+
+## Technology Stack Adaptation
+Choose your stack and apply these patterns consistently:
+
+### Frontend Options
+- **React/Next.js/Vue/Svelte**: Component-based with proper state management
+- **Angular**: Component + service architecture with TypeScript
+- **Traditional**: Server-side rendering with progressive enhancement
+
+### Backend Options  
+- **Node.js**: Express, Fastify, or framework API routes
+- **Python**: Django, FastAPI, Flask with proper ORM patterns
+- **Other**: Adapt patterns to your chosen backend technology
+
+### Database Options
+- **SQL**: PostgreSQL, MySQL with ORM (Prisma, TypeORM, SQLAlchemy)
+- **NoSQL**: MongoDB, DynamoDB with ODM patterns
+- **Cloud**: Supabase, Firebase, managed database services
+
+## Agent Delegation (See AGENTS.md for details)
+- **UI/Design work** → FrontendAgent
+- **API/Business logic** → BackendAgent  
+- **Database/Schema** → DatabaseAgent
+- **Testing implementation** → TestAgent
+- **Security reviews** → SecurityAgent
+- **Code quality** → ReviewerAgent
+
+## Usage Instructions
+1. Choose your technology stack
+2. Adapt the patterns in agents/rules/*.mdc to your chosen technologies
+3. Update this .cursorrules file with stack-specific details
+4. Begin development following the established patterns

package/templates/.gemini-instructions.md

@@ -0,0 +1,130 @@
+# Google Gemini AI Instructions
+
+This project uses enterprise-grade, technology-agnostic development patterns for all Google Gemini AI assistants, whether used through:
+- Google AI Studio (aistudio.google.com)
+- Gemini IDE extensions
+- Gemini API integration
+- Other Gemini-powered tools
+
+## Quick Start
+
+- **Project Guidelines**: See `CLAUDE.md`
+- **Agent Patterns**: See `AGENTS.md`
+- **Detailed Rules**: See `agents/rules/*.mdc` files
+- **Available Skills**: See `agents/skills/` directory
+
+## Core Development Patterns
+
+Follow these enterprise-grade patterns for all development work:
+
+### 1. Security-First Approach
+- **Validate all inputs**: Use schema validation for all user inputs and API requests
+- **Authentication**: Implement secure session management and authentication flows
+- **Authorization**: Apply role-based access control with proper middleware
+- **Rate limiting**: Protect public endpoints from abuse with appropriate rate limiting
+- **Error handling**: Never expose sensitive data in error messages or logs
+- **Database safety**: Use ORM/ODM patterns exclusively, avoid raw SQL queries
+- Reference: `agents/rules/security.mdc`
+
+### 2. Testing Requirements
+- **Unit tests**: Target 80% coverage for business logic
+- **Integration tests**: 15% coverage for API and database operations
+- **E2E tests**: 5% coverage for critical user journeys
+- All business logic must have appropriate test cases
+- Reference: `agents/rules/testing.mdc`
+
+### 3. Type Safety & Validation
+- Use strong typing systems available in your language of choice
+- Implement runtime validation at all API boundaries
+- Apply schema validation to form inputs and API requests
+- Reference: `agents/rules/core.mdc`
+
+### 4. Code Quality Standards
+- **Readability**: Clear variable names, proper documentation, logical organization
+- **Type safety**: Strict typing throughout, no loose type usage
+- **Performance**: Monitor resource usage, implement caching, optimize queries
+- **Maintainability**: Modular design, separation of concerns, SOLID principles
+- **Accessibility**: WCAG 2.1 AA compliance for all user-facing interfaces
+- Reference: `agents/rules/style.mdc`
+
+## Agent-Based Development
+
+This project follows an agent-based pattern where different roles handle different aspects:
+
+| Agent | Responsibility | Reference |
+|-------|-----------------|-----------|
+| **FrontendAgent** | UI/Design, components, accessibility, responsive layouts | `agents/rules/frontend.mdc` |
+| **BackendAgent** | API routes, business logic, authentication, services | `agents/rules/security.mdc` |
+| **DatabaseAgent** | Schema design, migrations, data access, optimization | `agents/rules/database.mdc` |
+| **TestAgent** | Testing strategy, coverage, test organization | `agents/rules/testing.mdc` |
+| **SecurityAgent** | Security patterns, validation, rate limiting, access control | `agents/rules/security.mdc` |
+| **ReviewerAgent** | Code quality, performance, accessibility, architecture | All rules |
+
+When implementing features, identify which agent responsibility applies and refer to the appropriate rules file.
+
+## Technology Stack Independence
+
+These patterns apply regardless of your tech stack. Adapt them to your chosen framework:
+
+### Frontend Frameworks
+- **React/Next.js/Vue/Svelte**: Component-based architecture with state management
+- **Angular**: Component + service pattern with TypeScript
+- **Traditional/Server-rendered**: Progressive enhancement with server-side rendering
+
+### Backend Frameworks
+- **Node.js**: Express, Fastify, Koa, or Next.js API routes
+- **Python**: Django, FastAPI, Flask with ORM patterns
+- **Go**: Gin, Echo, Fiber for high-performance APIs
+- **Other languages**: Apply patterns to your chosen framework
+
+### Database Technologies
+- **SQL**: PostgreSQL, MySQL, SQLite with ORM (Prisma, TypeORM, SQLAlchemy, etc.)
+- **NoSQL**: MongoDB, DynamoDB with schema validation
+- **Cloud-native**: Supabase, Firebase with built-in security
+
+## Critical Rules (Never Skip These)
+
+1. **Input Validation**: ALL user inputs must be validated with schema validation libraries
+2. **Authentication**: Implement secure authentication with proper session management
+3. **Rate Limiting**: Public endpoints MUST have rate limiting to prevent abuse
+4. **Authorization**: Role-based access control with verified permissions
+5. **Data Safety**: Never expose sensitive information in error responses
+6. **Database Access**: Use ORM/ODM exclusively, never raw queries for user data
+7. **Test Coverage**: Minimum 80% coverage for business logic
+8. **Accessibility**: WCAG 2.1 AA compliance for all user interfaces
+9. **Documentation**: Keep guides updated; code should be self-documenting
+10. **Performance**: Monitor metrics, implement caching, optimize critical paths
+
+## File Reference Guide
+
+| File | Purpose | When to Use |
+|------|---------|------------|
+| `CLAUDE.md` | Architecture and technology stack decisions | Need architectural guidance |
+| `AGENTS.md` | Agent responsibilities and delegation | Deciding who should implement a feature |
+| `agents/rules/core.mdc` | Core development principles | General development questions |
+| `agents/rules/security.mdc` | Security patterns and implementations | Building secure features |
+| `agents/rules/testing.mdc` | Testing strategy and best practices | Writing tests or test strategy |
+| `agents/rules/frontend.mdc` | Frontend patterns and components | Building UI features |
+| `agents/rules/database.mdc` | Database and data access patterns | Working with data layers |
+| `agents/rules/style.mdc` | Code style and formatting | Code style questions |
+| `agents/skills/` | Domain-specific implementations | Looking for reusable patterns |
+
+## Workflow Recommendations
+
+1. **Read CLAUDE.md** first to understand the overall architecture
+2. **Check AGENTS.md** to identify which agent should lead the implementation
+3. **Reference the appropriate rule file** for implementation patterns
+4. **Look in agents/skills/** for domain-specific guidance
+5. **Follow all critical rules** without exception
+6. **Apply patterns consistently** across the codebase
+
+## Additional Context
+
+- This template is **completely technology-agnostic** and works with any programming language
+- All patterns are **framework and language-independent**
+- The rules can be adapted to your specific tech stack while maintaining the security and quality principles
+- Skills in `agents/skills/` provide specific, actionable implementations
+
+---
+
+For best results with Gemini AI assistance, reference the appropriate rules files and provide the relevant context from `CLAUDE.md` and `AGENTS.md` in your prompts.

package/templates/.vscode-ai-rules.md

@@ -0,0 +1,111 @@
+# VSCode AI Rules
+
+This project uses enterprise-grade, technology-agnostic development patterns for all AI-powered development tools in VSCode, including:
+- GitHub Copilot Chat
+- IntelliCode
+- Other VSCode AI extensions
+
+## Quick References
+
+- **Project Guidelines**: See `CLAUDE.md`
+- **Agent Patterns**: See `AGENTS.md`
+- **Detailed Rules**: See `agents/rules/*.mdc` files
+- **Available Skills**: See `agents/skills/` directory
+
+## Core Rules for VSCode AI Assistants
+
+### 1. Security-First Development
+- Validate ALL user inputs with appropriate schema validation
+- Implement secure authentication flows with proper session management
+- Apply rate limiting to public API endpoints
+- Use role-based access control for authorization
+- Never expose sensitive data in error responses or logs
+- Reference: `agents/rules/security.mdc`
+
+### 2. Testing Strategy
+- Unit tests: 80% coverage of business logic
+- Integration tests: 15% coverage of API/database interactions
+- E2E tests: 5% coverage of critical user journeys
+- All business logic must have appropriate tests
+- Reference: `agents/rules/testing.mdc`
+
+### 3. Type Safety & Validation
+- Use strong typing available in your chosen language
+- Implement runtime validation at API boundaries
+- Apply schema validation to all form inputs and API requests
+- Reference: `agents/rules/core.mdc`
+
+## Agent Delegation Pattern
+
+When implementing features, follow the agent patterns from `AGENTS.md`:
+
+- **FrontendAgent**: UI/Design components, accessibility, responsive layouts
+- **BackendAgent**: API routes, business logic, authentication
+- **DatabaseAgent**: Schema design, migrations, data access patterns
+- **TestAgent**: Testing strategy, coverage, test organization
+- **SecurityAgent**: Security patterns, input validation, access control
+- **ReviewerAgent**: Code quality, performance, accessibility compliance
+
+## Technology Stack Adaptation
+
+These rules apply regardless of your chosen tech stack. Adapt them to your specific framework:
+
+### Frontend
+- **React/Next.js/Vue/Svelte**: Component-based with proper state management
+- **Angular**: Component + service architecture
+- **Traditional**: Server-side rendering with progressive enhancement
+
+### Backend
+- **Node.js**: Express, Fastify, or framework-specific patterns
+- **Python**: Django, FastAPI, Flask with ORM patterns
+- **Go**: Gin, Echo, or similar frameworks
+- **Other**: Adapt patterns to your chosen framework
+
+### Database
+- **SQL**: PostgreSQL, MySQL with ORM/migrations
+- **NoSQL**: MongoDB, DynamoDB with document validation
+- **Cloud**: Firebase, Supabase with row-level security
+
+## Critical Rules (MUST FOLLOW)
+
+1. **Input Validation**: ALL user inputs must be validated with schema validation
+2. **Authentication**: Implement secure, tested authentication flows
+3. **Rate Limiting**: Public endpoints MUST have rate limiting
+4. **Authorization**: Role-based access control with proper checks
+5. **Error Handling**: Never expose sensitive information in errors
+6. **Database**: Use ORM/ODM patterns, avoid raw queries
+7. **Testing**: All business logic must have appropriate test coverage
+8. **Accessibility**: WCAG 2.1 AA compliance for user-facing components
+9. **Documentation**: Keep README, CLAUDE.md, and AGENTS.md updated
+10. **Performance**: Monitor bundle size, implement lazy loading, optimize assets
+
+## Code Quality Standards
+
+- **Type Safety**: Strict typing, no loose type usage
+- **Readability**: Clear names, proper documentation, logical organization
+- **Performance**: Efficient algorithms, appropriate caching
+- **Maintainability**: Modular design, separation of concerns, SOLID principles
+
+## When to Reference Each File
+
+- **CLAUDE.md**: For architecture decisions and technology stack guidance
+- **AGENTS.md**: For agent responsibilities and when to delegate
+- **agents/rules/*.mdc**: For specific implementation patterns:
+  - `core.mdc`: Core principles and architecture
+  - `security.mdc`: Security patterns and best practices
+  - `testing.mdc`: Testing strategy and patterns
+  - `frontend.mdc`: Frontend development patterns
+  - `database.mdc`: Database and data access patterns
+  - `style.mdc`: Code style and formatting guidelines
+- **agents/skills/**: For reusable domain-specific implementations
+
+## For More Information
+
+Explore the `agents/skills/` directory for domain-specific guidance on common tasks:
+- Each skill provides specific, actionable guidance
+- Reference skills when implementing similar features
+- Skills build on the core rules above
+
+---
+
+All AI assistants in VSCode should follow these rules consistently to maintain code quality, security, and maintainability across the project.

package/templates/AI_INSTRUCTIONS.md

@@ -17,6 +17,7 @@ When implementing features, always check the relevant rule file:
 - **`agents/rules/frontend.mdc`** - Frontend development patterns, component architecture, accessibility
 - **`agents/rules/database.mdc`** - Database schema design, migrations, query optimization
 - **`agents/rules/style.mdc`** - Code style guidelines, formatting rules, naming conventions
+- **`agents/rules/workflows.mdc`** - Development workflow (validate, doctor, pre-commit)
 
 ## Usage Workflow
 

package/templates/CLAUDE.md

@@ -4,7 +4,7 @@ This is a **technology-agnostic development template** with enterprise-grade pat
 These guidelines are for both humans and AI assistants working with any technology stack.
 
 - High-level **project and architecture** guidelines live here in `CLAUDE.md`.
-- **Agent responsibilities** and MCP integration are documented in `AGENTS.md`.
+- **Agent responsibilities** and MCP integration are documented in `AGENTS.MD`.
 - **Detailed implementation rules** live in `agents/rules/*.mdc` files.
 
 Read this file first to understand the architecture, then consult `AGENTS.md` for agent delegation.
@@ -234,7 +234,7 @@ Review the options above and select technologies that fit your:
 - Set up deployment pipelines and environment management
 
 ### 4. Follow Agent Patterns
-- Use the agents defined in `AGENTS.md` for specialized tasks
+- Use the agents defined in `AGENTS.MD` for specialized tasks
 - Maintain consistency with established patterns
 - Regular code reviews using `ReviewerAgent` patterns
 - Document architectural decisions as you build
@@ -255,4 +255,7 @@ Review the options above and select technologies that fit your:
 - **Security patches**: Immediate application of critical security updates
 - **Performance improvements**: Adoption of new optimization techniques
 
+### How We Improve This Package (Maintainers)
+When improving the agents-templated package itself, maintainers use **NotebookLM** (research and best-practice discourse) and **Context7** (up-to-date library and framework docs) to gather insights. Use both to improve the **system itself**—templates, rules, and skills—by querying Cursor rules best practices, agent-rules patterns, and template/scaffolding guides, then refining rules, skills, and template content. Run the audit dimensions (docs, rules, CLI, presets, validate/doctor, tests), prioritize changes, then validate with `agents-templated validate` and `doctor`. See the README section "Improvement and Maintenance" for the full process.
+
 This template provides a solid foundation while remaining flexible for any technology stack you choose to implement.

package/templates/README.md

@@ -1,4 +1,4 @@
-# Technology-Agnostic Development Template
+# Technology-Agnostic Development Template
 
 This template has been installed by the agents-templated npm package.
 
@@ -31,6 +31,11 @@ agents-templated init --github    # GitHub Copilot config only
 agents-templated list
 ```
 
+## Rules and Skills
+
+- **Rules** (`agents/rules/*.mdc`): Markdown files with YAML frontmatter (`description`, `globs`, `alwaysApply`). Cursor and other tools use them to know when to apply each rule. Adapt the content to your stack.
+- **Skills** (`agents/skills/*/SKILL.md`): Extend agent capabilities (e.g. find-skills, web-design-guidelines). Each has a name, description, and when to use.
+
 ## Getting Started
 
 1. Review CLAUDE.md for overall project guidelines

package/templates/agents/rules/core.mdc

@@ -1,4 +1,4 @@
----
+---
 title: "Core Project Guidelines"
 description: "Enterprise-grade architecture and best practices for technology-agnostic development"
 alwaysApply: true
@@ -151,6 +151,14 @@ This template is technology-agnostic. Choose your stack based on:
 - **Feature adoption** - stay current with language/framework improvements
 - **Deprecation management** - handle deprecated APIs and patterns
 
+## Documentation and Research
+
+When deciding what to recommend or implement:
+
+- **Local rules** (this file and other `agents/rules/*.mdc`): Use as the primary source for architecture, security, testing, and style. Follow these when the stack is generic or already covered.
+- **Context7 MCP**: Use for **up-to-date library and framework documentation**. When suggesting or implementing patterns for a specific stack (e.g. Next.js, Express, React), query Context7 (`resolve-library-id` then `query-docs`) so recommendations match current APIs and official guidance.
+- **NotebookLM MCP**: Use for **research and best-practice discourse** (e.g. OWASP, building-systems advice, template design). Query when adding or changing guidelines, or when the audit/planning needs external best practices. Not for real-time API docs—use Context7 for that.
+
 ## Communication & Collaboration
 
 - When providing solutions, be explicit about what to change
@@ -162,4 +170,4 @@ This template is technology-agnostic. Choose your stack based on:
 ---
 
 Remember: This template adapts to **any modern technology stack** while maintaining **enterprise-grade quality standards**.
-Choose your technologies wisely, apply these principles consistently, and keep your codebase maintainable.
+Choose your technologies wisely, apply these principles consistently, and keep your codebase maintainable.

package/templates/agents/rules/workflows.mdc

@@ -0,0 +1,49 @@
+---
+title: "Development Workflow Guidelines"
+description: "Optional development workflow: project health checks and pre-commit quality gates"
+alwaysApply: false
+version: "1.0.0"
+tags: ["workflow", "quality", "validation", "commit"]
+globs:
+  - "**/*"
+---
+
+# Development Workflow Guidelines
+
+Technology-agnostic suggestions for keeping the project healthy and maintaining quality before commits.
+
+## When This Rule Applies
+
+Use this guidance when the user asks about workflow, pre-commit checks, or keeping the project validated. Do not force these steps on every change—treat them as recommended practices.
+
+## Project Health (agents-templated)
+
+If this project was scaffolded with agents-templated:
+
+- **Periodically**: Run `agents-templated validate` to ensure required docs and rules are present; run `agents-templated doctor` for environment and configuration recommendations.
+- **After pulling template updates**: Run `agents-templated update --check-only` to see available updates, then `agents-templated update` if you want to apply them (with backup).
+
+These commands help keep agent rules, documentation, and security patterns in sync.
+
+## Pre-Commit Quality Gates
+
+Before committing, consider running (in order):
+
+1. **Lint** – Your stack’s linter (e.g. ESLint, Pylint, golangci-lint) to catch style and simple issues.
+2. **Type check** – If applicable (TypeScript, mypy, etc.) to catch type errors.
+3. **Tests** – At least the fast test suite (e.g. unit tests) so regressions are caught early.
+4. **Project validation** – For agents-templated projects, `agents-templated validate` can confirm setup is intact.
+
+Do not commit with failing lint or tests unless the user explicitly requests a WIP commit (e.g. with `--no-verify` or a clear “work in progress” message).
+
+## Commit Messages
+
+- Prefer clear, descriptive messages (e.g. conventional commits: `feat:`, `fix:`, `docs:`).
+- Reference issues or tickets when relevant (e.g. “Closes #123”).
+- Keep the body focused on what changed and why, not how.
+
+## Summary
+
+- Use **agents-templated validate** and **doctor** to maintain project setup and get recommendations.
+- Run **lint**, **type check**, and **tests** before committing when possible.
+- Write clear commit messages and reference issues where applicable.

package/templates/presets/django-react.json

@@ -8,6 +8,7 @@
     "language": "Python + TypeScript"
   },
   "components": ["docs", "rules", "skills", "github"],
+  "supportedAgents": ["cursor", "copilot", "vscode", "gemini"],
   "recommendedPackages": {
     "python": [
       "django",

package/templates/presets/express-api.json

@@ -7,6 +7,7 @@
     "language": "TypeScript"
   },
   "components": ["docs", "rules", "skills", "github"],
+  "supportedAgents": ["cursor", "copilot", "vscode", "gemini"],
   "recommendedPackages": [
     "express",
     "typescript",

package/templates/presets/fastapi.json

@@ -7,6 +7,7 @@
     "language": "Python"
   },
   "components": ["docs", "rules", "skills", "github"],
+  "supportedAgents": ["cursor", "copilot", "vscode", "gemini"],
   "recommendedPackages": [
     "fastapi",
     "uvicorn",

package/templates/presets/go-api.json

@@ -7,6 +7,7 @@
     "language": "Go"
   },
   "components": ["docs", "rules", "skills", "github"],
+  "supportedAgents": ["cursor", "copilot", "vscode", "gemini"],
   "recommendedPackages": [
     "github.com/gin-gonic/gin",
     "github.com/lib/pq",

package/templates/presets/nextjs.json

@@ -8,6 +8,7 @@
     "language": "TypeScript"
   },
   "components": ["docs", "rules", "skills", "github"],
+  "supportedAgents": ["cursor", "copilot", "vscode", "gemini"],
   "recommendedPackages": [
     "next",
     "react",