MoAI Command Project - Integrated Project Management System

Purpose: Comprehensive project management system that integrates documentation generation, multilingual support, and template optimization into unified architecture with intelligent automation and Claude Code integration.

Scope: Consolidates documentation management, language initialization, and template optimization into single cohesive system supporting complete project lifecycle from initialization to maintenance.

Target: Claude Code agents for project setup, documentation generation, multilingual support, and performance optimization.

---

Quick Reference (30 seconds)

Core Modules:

• DocumentationManager: Template-based documentation generation with multilingual support
• LanguageInitializer: Language detection, configuration, and localization management
• TemplateOptimizer: Advanced template analysis and performance optimization
• MoaiMenuProject: Unified interface integrating all modules

Quick Start:

# Complete project initialization
from moai_menu_project import MoaiMenuProject

project = MoaiMenuProject("./my-project")
result = project.initialize_complete_project(
 language="en",
 user_name="Developer Name", 
 domains=["backend", "frontend"],
 project_type="web_application"
)

Key Features:

• Automatic project type detection and template selection
• Multilingual documentation generation (en, ko, ja, zh)
• Intelligent template optimization with performance benchmarking
• SPEC-driven documentation updates
• Multi-format export (markdown, HTML, PDF)

---

Implementation Guide

Module Architecture

DocumentationManager:

• Template-based documentation generation
• Project type detection (web, mobile, CLI, library, ML)
• Multilingual support with localized content
• SPEC data integration for automatic updates
• Multi-format export capabilities

LanguageInitializer:

• Automatic language detection from project content
• Comprehensive language configuration management
• Agent prompt localization with cost optimization
• Domain-specific language support
• Locale management and cultural adaptation

TemplateOptimizer:

• Advanced template analysis with complexity metrics
• Performance optimization with size reduction
• Intelligent backup and recovery system
• Benchmarking and performance tracking
• Automated optimization recommendations

Core Workflows

Complete Project Initialization:

# Step 1: Initialize integrated system
project = MoaiMenuProject("/path/to/project")

# Step 2: Complete setup with all modules
result = project.initialize_complete_project(
 language="ko", # Korean language support
 user_name="",
 domains=["backend", "frontend", "mobile"],
 project_type="web_application",
 optimization_enabled=True
)

# Result includes:
# - Language configuration with token cost analysis
# - Documentation structure creation
# - Template analysis and optimization
# - Multilingual documentation setup

Documentation Generation from SPEC:

# SPEC data for feature documentation
spec_data = {
 "id": "SPEC-001",
 "title": "User Authentication System",
 "description": "Implement secure authentication with JWT",
 "requirements": [
 "User registration with email verification",
 "JWT token generation and validation",
 "Password reset functionality"
 ],
 "status": "Planned",
 "priority": "High",
 "api_endpoints": [
 {
 "path": "/api/auth/login",
 "method": "POST",
 "description": "User login endpoint"
 }
 ]
}

# Generate comprehensive documentation
docs_result = project.generate_documentation_from_spec(spec_data)

# Results include:
# - Feature documentation with requirements
# - API documentation with endpoint details
# - Updated project documentation files
# - Multilingual versions if configured

Template Performance Optimization:

# Analyze current templates
analysis = project.template_optimizer.analyze_project_templates()

# Apply optimizations with backup
optimization_options = {
 "backup_first": True,
 "apply_size_optimizations": True,
 "apply_performance_optimizations": True,
 "apply_complexity_optimizations": True,
 "preserve_functionality": True
}

optimization_result = project.optimize_project_templates(optimization_options)

# Results include:
# - Size reduction percentage
# - Performance improvement metrics
# - Backup creation confirmation
# - Detailed optimization report

Language and Localization

Automatic Language Detection:

# System analyzes project for language indicators
language = project.language_initializer.detect_project_language()

# Detection methods:
# - File content analysis (comments, strings)
# - Configuration file examination
# - System locale detection
# - Directory structure patterns

Multilingual Documentation:

# Create documentation structure for multiple languages
multilingual_result = project.language_initializer.create_multilingual_documentation_structure("ko")

# Creates:
# - /docs/ko/ - Korean documentation
# - /docs/en/ - English fallback 
# - Language negotiation configuration
# - Automatic redirection setup

Agent Prompt Localization:

# Localize agent prompts with cost consideration
localized_prompt = project.language_initializer.localize_agent_prompts(
 base_prompt="Generate user authentication system",
 language="ko"
)

# Result includes:
# - Korean language instructions
# - Cultural context adaptations
# - Token cost optimization recommendations

Template Optimization

Performance Analysis:

# Comprehensive template analysis
analysis = project.template_optimizer.analyze_project_templates()

# Analysis includes:
# - File size and complexity metrics
# - Performance bottleneck identification
# - Optimization opportunity scoring
# - Resource usage patterns
# - Backup recommendations

Intelligent Optimization:

# Create optimized versions with backup
optimization_result = project.template_optimizer.create_optimized_templates({
 "backup_first": True,
 "apply_size_optimizations": True,
 "apply_performance_optimizations": True,
 "apply_complexity_optimizations": True
})

# Optimizations applied:
# - Whitespace and redundancy reduction
# - Template structure optimization
# - Complexity reduction techniques
# - Performance caching improvements

Configuration Management

Integrated Configuration:

# Get comprehensive project status
status = project.get_project_status()

# Status includes:
# - Project metadata and type
# - Language configuration and costs
# - Documentation completion status
# - Template optimization results
# - Module initialization states

Language Settings Updates:

# Update language configuration
update_result = project.update_language_settings({
 "language.conversation_language": "ja",
 "language.agent_prompt_language": "english", # Cost optimization
 "language.documentation_language": "ja"
})

# Automatic updates:
# - Configuration file changes
# - Documentation structure updates
# - Template localization adjustments

---

Advanced Implementation (10+ minutes)

For advanced patterns including custom template development, performance optimization strategies, and integration workflows, see:

• Advanced Patterns: Custom templates, caching, batch processing
• Integration Workflows: Complete project lifecycle and multilingual management
• Performance Optimization: Template caching and batch optimization strategies

Resources

Module Files

Core Implementation:

• modules/documentation_manager.py - Documentation generation and management
• modules/language_initializer.py - Language detection and configuration
• modules/template_optimizer.py - Template analysis and optimization
• __init__.py - Unified interface and integration logic

Templates and Examples:

• templates/doc-templates/ - Documentation template collection
• examples/complete_project_setup.py - Comprehensive usage examples
• examples/quick_start.py - Quick start guide

Configuration Files

Project Configuration:

{
 "project": {
 "name": "My Project",
 "type": "web_application",
 "initialized_at": "2025-11-25T..."
 },
 "language": {
 "conversation_language": "en",
 "agent_prompt_language": "english",
 "documentation_language": "en"
 },
 "menu_system": {
 "version": "1.0.0",
 "fully_initialized": true
 }
}

Language Configuration:

{
 "en": {
 "name": "English",
 "native_name": "English",
 "code": "en",
 "locale": "en_US.UTF-8",
 "agent_prompt_language": "english",
 "token_cost_impact": 0
 },
 "ko": {
 "name": "Korean",
 "native_name": "", 
 "code": "ko",
 "locale": "ko_KR.UTF-8",
 "agent_prompt_language": "localized",
 "token_cost_impact": 20
 }
}

Works Well With

• moai-foundation-core - For core execution patterns and SPEC-driven development workflows
• moai-foundation-claude - For Claude Code integration and configuration
• moai-workflow-docs - For unified documentation management
• moai-workflow-templates - For template optimization strategies
• moai-library-nextra - For advanced documentation architecture

Integration Examples

Command Line Usage:

# CLI interface for project management
python -m moai_menu_project.cli init --language ko --domains backend,frontend
python -m moai_menu_project.cli generate-docs --spec-file SPEC-001.json
python -m moai_menu_project.cli optimize-templates --backup
python -m moai_menu_project.cli export-docs --format html --language ko

API Integration:

# REST API integration example
from moai_menu_project import MoaiMenuProject

app = FastAPI()

@app.post("/projects/{project_id}/initialize")
async def initialize_project(project_id: str, config: ProjectConfig):
 project = MoaiMenuProject(f"./projects/{project_id}")
 result = project.initialize_complete_project(config.dict())
 return result

@app.post("/projects/{project_id}/docs")
async def generate_docs(project_id: str, spec_data: SpecData):
 project = MoaiMenuProject(f"./projects/{project_id}")
 result = project.generate_documentation_from_spec(spec_data.dict())
 return result

Performance Metrics

Module Performance:

• Documentation Generation: ~2-5 seconds for complete documentation
• Language Detection: ~500ms for average project analysis
• Template Optimization: ~10-30 seconds depending on project size
• Configuration Updates: ~100ms for language setting changes

Memory Usage:

• Base System: ~50MB RAM usage
• Large Projects: Additional ~10-50MB depending on template count
• Optimization Cache: ~5-20MB for performance improvements

File Size Impact:

• Documentation: ~50-200KB per project
• Optimization Backups: Size of original templates
• Configuration: ~5-10KB for complete project setup

---

Version: 1.0.0 Last Updated: 2025-11-25 Integration Status: Complete - All modules implemented and tested