moai-workflow-templates

# Enterprise Template Management

Unified template system combining code boilerplates, feedback templates, and project optimization workflows for rapid development and consistent patterns.

## Quick Reference

Core Capabilities:

- Code template library for FastAPI, React, Vue, and Next.js
- GitHub issue feedback templates covering 6 types
- Project template optimization and smart merging
- Template version management and history
- Backup discovery and restoration
- Pattern reusability and customization

When to Use:

- Scaffolding new projects or features
- Creating GitHub issues with /moai:9-feedback
- Optimizing template structures after MoAI-ADK updates
- Restoring from project backups
- Managing template versions and customizations
- Generating boilerplate code

Key Features:

- Code Templates: FastAPI, React, Vue, Docker, and CI/CD templates
- Feedback Templates: 6 GitHub issue types including bug, feature, improvement, refactor, docs, and question
- Template Optimizer: Smart merge, backup restoration, and version tracking
- Pattern Library: Reusable patterns for common scenarios

Quick Access to Modules:

- Code Templates documentation in modules/code-templates.md
- Feedback Templates documentation in modules/feedback-templates.md
- Template Optimizer documentation in modules/template-optimizer.md

## Implementation Guide

### Features

- Project templates for common architectures
- Boilerplate code generation with best practices
- Configurable template variables and customization
- Multi-framework support including React, FastAPI, and Spring
- Integrated testing and CI/CD configurations

### When to Use

- Bootstrapping new projects with proven architecture patterns
- Ensuring consistency across multiple projects in an organization
- Quickly prototyping new features with proper structure
- Onboarding new developers with standardized project layouts
- Generating microservices or modules following team conventions

### Core Patterns

Pattern 1 - Template Structure:

Templates are organized in a directory hierarchy. The top-level templates directory contains framework-specific subdirectories. A backend framework directory such as fastapi-backend contains template.json for variables and a src directory with main.py, models subdirectory, and tests subdirectory. A frontend framework directory such as nextjs-frontend contains template.json, app directory, and components directory. A fullstack template contains separate backend and frontend subdirectories.

Pattern 2 - Template Variables:

Template variables are defined in a JSON configuration file with two main sections. The variables section defines key-value pairs such as PROJECT_NAME, AUTHOR, LICENSE, and PYTHON_VERSION. The files section maps file patterns to processing modes: files marked as substitute have variables replaced, while files marked as copy are transferred unchanged.

Pattern 3 - Template Generation:

The template generation process follows five steps. First, load the template directory structure. Second, substitute variables in files marked for substitution. Third, copy static files as-is. Fourth, run post-generation hooks such as dependency installation and git initialization. Fifth, validate the generated project structure.

## Core Patterns in Detail

### Pattern 1: Code Template Scaffolding

Concept: Rapidly scaffold projects with production-ready boilerplates.

To generate a project, load the appropriate template such as backend/fastapi. Configure the scaffold with the project name, desired features such as auth, database, and celery, and customizations such as database type. Execute the scaffold to create the project structure.

For complete library and examples, see the Code Templates module documentation.

---

### Pattern 2: GitHub Feedback Templates

Concept: Structured templates for consistent GitHub issue creation.

Six Template Types: Bug Report, Feature Request, Improvement, Refactor, Documentation, and Question/Discussion.

Integration: Auto-triggered by the /moai:9-feedback command.

For all template types and usage, see the Feedback Templates module documentation.

---

### Pattern 3: Template Optimization and Smart Merge

Concept: Intelligently merge template updates while preserving user customizations.

Smart Merge Algorithm: The three-way merge process works as follows. First, extract user customizations from the backup. Second, get the latest template defaults from the current templates. Third, merge with appropriate priority where template_structure uses the latest defaults, user_config preserves user settings, and custom_content retains user modifications.

For complete workflow and examples, see the Template Optimizer module documentation.

---

### Pattern 4: Backup Discovery and Restoration

Concept: Automatic backup management with intelligent restoration.

Restoration Process: The process follows four steps. First, load backup metadata using the backup identifier. Second, validate backup integrity and raise an error if the backup is corrupted. Third, extract customizations from the validated backup. Fourth, apply the extracted customizations to the current project.

For complete implementation, see the Template Optimizer module section on Restoration Process.

---

### Pattern 5: Template Version Management

Concept: Track template versions and maintain update history.

Version Tracking: The template_optimization configuration section stores last_optimized timestamp, backup_version identifier, template_version number, and customizations_preserved list containing items like language, team_settings, and domains.

For complete implementation, see the Template Optimizer module section on Version Tracking.

---

## Module Reference

### Core Modules

- Code Templates in modules/code-templates.md: Boilerplate library, scaffold patterns, and framework templates
- Feedback Templates in modules/feedback-templates.md: 6 GitHub issue types, usage examples, and best practices
- Template Optimizer in