agentic-team-templates 0.14.0 → 0.16.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-team-templates",
-  "version": "0.14.0",
+  "version": "0.16.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

@@ -48,6 +48,10 @@ const TEMPLATES = {
     description: 'Technical documentation standards (READMEs, API docs, ADRs, code comments)',
     rules: ['adr.md', 'api-documentation.md', 'code-comments.md', 'maintenance.md', 'overview.md', 'readme-standards.md']
   },
+  'educator': {
+    description: 'World-class pedagogy with evidence-based teaching, learning retention, gamification, and assessment design',
+    rules: ['accessibility.md', 'assessment.md', 'curriculum.md', 'engagement.md', 'instructional-design.md', 'overview.md', 'retention.md']
+  },
   'fullstack': {
     description: 'Full-stack web applications (Next.js, Nuxt, SvelteKit, Remix)',
     rules: ['api-contracts.md', 'architecture.md', 'overview.md', 'shared-types.md', 'testing.md']
@@ -118,6 +122,38 @@ 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',
+  'teach': 'educator',
+  'teacher': 'educator',
+};
+
+/**
+ * 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', 
@@ -215,7 +251,20 @@ ${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
+  teach, teacher                 → educator
+
 ${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
@@ -237,13 +286,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', '')}`);
@@ -1378,10 +1438,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;
 
@@ -1391,7 +1454,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);
@@ -1410,14 +1473,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();
@@ -1432,18 +1495,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();
@@ -1460,7 +1523,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
@@ -1470,11 +1533,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,
@@ -80,6 +82,7 @@ describe('Constants', () => {
         'data-engineering',
         'devops-sre',
         'documentation',
+        'educator',
         'fullstack',
         'golang-expert',
         'java-expert',
@@ -150,6 +153,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');
+    });
+  });
 });
 
 // ============================================================================
@@ -1019,7 +1066,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/educator/.cursorrules/accessibility.md

@@ -0,0 +1,266 @@
+# Accessibility and Inclusive Education
+
+Universal Design for Learning and evidence-based practices for reaching every learner.
+
+## Universal Design for Learning (CAST)
+
+### Three UDL Principles
+
+```
+UDL Framework
+├── Principle I: Multiple Means of REPRESENTATION (the "what" of learning)
+│   ├── Provide options for perception
+│   ├── Provide options for language and symbols
+│   └── Provide options for comprehension
+│
+├── Principle II: Multiple Means of ACTION & EXPRESSION (the "how" of learning)
+│   ├── Provide options for physical action
+│   ├── Provide options for expression and communication
+│   └── Provide options for executive functions
+│
+└── Principle III: Multiple Means of ENGAGEMENT (the "why" of learning)
+    ├── Provide options for recruiting interest
+    ├── Provide options for sustaining effort and persistence
+    └── Provide options for self-regulation
+```
+
+### UDL Implementation Guide
+
+| Principle | Guideline | Practical Example |
+|-----------|-----------|-------------------|
+| Representation | Offer alternatives for visual info | Provide text descriptions for images, transcripts for videos |
+| Representation | Clarify vocabulary and symbols | Define key terms, provide glossaries, use consistent notation |
+| Representation | Activate prior knowledge | Start lessons with connections to what learners already know |
+| Action & Expression | Vary methods for response | Allow written, verbal, visual, or multimedia submissions |
+| Action & Expression | Support planning and strategy | Provide checklists, graphic organizers, project timelines |
+| Action & Expression | Facilitate managing information | Offer templates, note-taking guides, categorization tools |
+| Engagement | Optimize individual choice | Let learners choose topics, tools, or assessment formats |
+| Engagement | Foster collaboration | Structured group work with clear roles and accountability |
+| Engagement | Develop self-assessment | Teach learners to use rubrics to evaluate their own work |
+
+### UDL Checkpoint: Lesson Review
+
+```markdown
+Before delivering a lesson, check:
+
+Representation:
+- [ ] Content is available in at least 2 formats (text + visual, audio + text)
+- [ ] Key vocabulary is explicitly defined
+- [ ] Background knowledge is activated
+
+Action & Expression:
+- [ ] Learners have more than one way to demonstrate understanding
+- [ ] Scaffolds are available (templates, graphic organizers, exemplars)
+- [ ] Technology options are flexible and accessible
+
+Engagement:
+- [ ] Learners have meaningful choices
+- [ ] Goals are clear and relevant to learners
+- [ ] Collaboration is structured with clear expectations
+```
+
+## Differentiated Instruction
+
+### Differentiation Model (Tomlinson)
+
+```
+Differentiate by:
+├── Content: WHAT learners study
+│   └── Same concept, different complexity or resources
+├── Process: HOW learners make sense of it
+│   └── Same goal, different activities or scaffolding
+├── Product: HOW learners demonstrate learning
+│   └── Same objectives, different output formats
+└── Environment: WHERE and WITH WHOM learners work
+    └── Same classroom, different grouping and settings
+```
+
+### Differentiation Strategies
+
+| Strategy | Description | Example |
+|----------|-------------|---------|
+| Tiered assignments | Same objective, varying complexity | All students analyze a text; Tier 1 guided questions, Tier 2 open analysis, Tier 3 comparative analysis |
+| Flexible grouping | Group by readiness, interest, or learning preference | Readiness groups for skill practice; mixed groups for projects |
+| Learning menus | Choice board of activities aligned to objectives | "Choose 3 from this menu to demonstrate your understanding" |
+| Anchor activities | Meaningful work for early finishers | Extension problems, enrichment readings, peer tutoring |
+| Compacting | Pre-test to skip mastered content | Students who demonstrate mastery work on extension projects |
+
+### Tiered Assignment Template
+
+```markdown
+Objective: [Same for all tiers]
+
+Tier 1 (Approaching):
+- Scaffolded task with guided steps
+- Graphic organizer provided
+- Worked example available for reference
+
+Tier 2 (Meeting):
+- Standard task with minimal scaffolding
+- Choice of graphic organizer (optional)
+- Peer collaboration encouraged
+
+Tier 3 (Exceeding):
+- Extended task requiring transfer to new context
+- Open-ended approach
+- Independent or mentoring others
+```
+
+## Learning Styles: The Myth
+
+### What the Research Says
+
+```markdown
+IMPORTANT: The "learning styles" model (visual, auditory, kinesthetic)
+is NOT supported by research evidence.
+
+The "meshing hypothesis" — that matching instruction to preferred
+learning style improves outcomes — has been tested repeatedly
+and consistently fails to show benefits.
+
+Key studies:
+- Pashler et al. (2008): Comprehensive review found no credible evidence
+- Rogowsky et al. (2015): No interaction between style and instruction format
+- Husmann & O'Loughlin (2019): Students didn't even study in their "preferred" style
+
+What DOES work:
+- Multiple representations of content (UDL) — benefits ALL learners
+- Matching modality to CONTENT type (diagrams for spatial, text for verbal)
+- Active learning strategies regardless of supposed "style"
+```
+
+### What to Do Instead
+
+```markdown
+❌ "This student is a visual learner, so only use diagrams"
+✅ "All students benefit from multiple representations (UDL Principle I)"
+
+❌ Assess students' learning styles and customize per student
+✅ Provide content in multiple formats for everyone
+
+The goal is not matching to preference; it is matching to content:
+- Geography → maps (visual makes sense for the CONTENT)
+- Music → audio (auditory makes sense for the CONTENT)
+- Vocabulary → verbal definitions + visual examples (dual coding helps ALL)
+```
+
+## Inclusive Content Design
+
+### Language and Representation
+
+```markdown
+Inclusive practices:
+- Use diverse names, contexts, and scenarios in examples
+- Avoid stereotypes in case studies and problem contexts
+- Represent multiple cultures, backgrounds, and perspectives
+- Use gender-inclusive language
+- Present multiple viewpoints on complex topics
+```
+
+### Culturally Responsive Teaching
+
+| Principle | Practice |
+|-----------|----------|
+| High expectations for all | Hold rigorous standards while providing support to meet them |
+| Cultural competence | Learn about students' backgrounds; incorporate into instruction |
+| Critical consciousness | Connect learning to real-world issues students care about |
+| Student voice | Create space for students to share perspectives and experiences |
+| Asset-based framing | Focus on what students bring, not what they lack |
+
+### Accessible Materials Checklist
+
+```markdown
+Text:
+- [ ] Sans-serif font, minimum 12pt (14pt preferred)
+- [ ] High contrast (minimum 4.5:1 ratio)
+- [ ] Left-aligned (not justified)
+- [ ] 1.5 line spacing minimum
+- [ ] Clear heading hierarchy (H1, H2, H3)
+
+Images:
+- [ ] Alt text for all meaningful images
+- [ ] Decorative images marked as decorative
+- [ ] No information conveyed by color alone
+
+Video:
+- [ ] Captions for all spoken content
+- [ ] Audio descriptions for visual-only content
+- [ ] Transcript available
+
+Documents:
+- [ ] Proper heading structure (not just bold/large text)
+- [ ] Tables have header rows
+- [ ] Links have descriptive text (not "click here")
+- [ ] Reading order is logical for screen readers
+
+Assessment:
+- [ ] Extended time available when appropriate
+- [ ] Alternative formats offered (oral, written, visual)
+- [ ] Instructions are clear and unambiguous
+- [ ] Examples are provided for unfamiliar formats
+```
+
+## Supporting Diverse Learners
+
+### English Language Learners
+
+| Strategy | Description |
+|----------|-------------|
+| Visual supports | Pair text with images, diagrams, and real objects |
+| Sentence frames | Provide structured templates for academic language |
+| Word walls | Display key vocabulary with definitions and visuals |
+| Wait time | Allow extra processing time (7-10 seconds) |
+| Preview/review | Introduce key concepts before, review after |
+| Collaborative structures | Pair with bilingual peers for support |
+
+### Learners with Disabilities
+
+```markdown
+Focus on BARRIERS, not deficits:
+
+❌ "This student can't learn because of their disability"
+✅ "What barriers in the learning environment can we remove?"
+
+Universal design removes barriers proactively:
+- Flexible materials (digital text that can be resized, read aloud)
+- Multiple means of expression (don't require handwriting if typing works)
+- Flexible timing (mastery matters more than speed)
+- Accessible technology (screen readers, speech-to-text, magnification)
+```
+
+### Gifted and Advanced Learners
+
+| Strategy | Description |
+|----------|-------------|
+| Curriculum compacting | Pre-test and skip mastered content |
+| Depth and complexity | Add layers of analysis, not just more work |
+| Independent study | Self-directed projects on topics of interest |
+| Mentorship | Connect with experts in areas of passion |
+| Acceleration | Move faster through content when mastery is demonstrated |
+
+```markdown
+❌ "You finished early? Do 10 more problems" (busywork)
+✅ "You've mastered this. Here's a challenge that extends the concept
+    to a new context" (depth, not volume)
+```
+
+## Trauma-Informed Practices
+
+### Core Principles
+
+```markdown
+1. Safety: Create physically and emotionally safe spaces
+2. Trustworthiness: Be consistent, transparent, and follow through
+3. Choice: Offer control wherever possible
+4. Collaboration: Work WITH students, not ON them
+5. Empowerment: Build on strengths; foster resilience
+```
+
+### Classroom Strategies
+
+- Establish predictable routines
+- Provide advance notice of changes
+- Offer quiet spaces for self-regulation
+- Use calm, regulated tone
+- Avoid public shaming or confrontation
+- Build relationships before demanding compliance