mongodb-memory-bank-mcp/dist/domain/entities/memory-templates.js

FIXED: MongoDB Memory Bank MCP with bulletproof error handling, smart operations, and session state management. Eliminates [object Object] errors and user confusion.

/**
 * Core Memory Templates
 * Based on alioshr/memory-bank-mcp patterns with MongoDB enhancements
 * Designed for perfect harmony with existing universal detection system
 */
export const CORE_MEMORY_TEMPLATES = {
    'project-brief': {
        type: 'project-brief',
        version: '1.0.0',
        name: 'Project Brief',
        description: 'Core project requirements, goals, and high-level context',
        schema: {
            sections: [
                {
                    name: 'Project Overview',
                    description: 'High-level project description and purpose',
                    required: true,
                    format: 'markdown',
                    placeholder: '## Project Overview\n\nDescribe the project purpose, goals, and key objectives...'
                },
                {
                    name: 'Key Requirements',
                    description: 'Essential functional and non-functional requirements',
                    required: true,
                    format: 'markdown',
                    placeholder: '## Key Requirements\n\n### Functional Requirements\n- \n\n### Non-Functional Requirements\n- '
                },
                {
                    name: 'Success Criteria',
                    description: 'Measurable success indicators',
                    required: true,
                    format: 'markdown',
                    placeholder: '## Success Criteria\n\n1. \n2. \n3. '
                },
                {
                    name: 'Constraints',
                    description: 'Technical, business, or resource constraints',
                    required: false,
                    format: 'markdown',
                    placeholder: '## Constraints\n\n### Technical Constraints\n- \n\n### Business Constraints\n- '
                }
            ],
            requiredFields: ['Project Overview', 'Key Requirements', 'Success Criteria'],
            optionalFields: ['Constraints']
        },
        defaultContent: `# Project Brief

## Project Overview

[Describe the project purpose, goals, and key objectives]

## Key Requirements

### Functional Requirements
- [List essential features and capabilities]

### Non-Functional Requirements
- [Performance, security, scalability requirements]

## Success Criteria

1. [Measurable success indicator 1]
2. [Measurable success indicator 2]
3. [Measurable success indicator 3]

## Constraints

### Technical Constraints
- [Technology limitations or requirements]

### Business Constraints
- [Budget, timeline, or resource limitations]

---
*Generated by MongoDB Memory Bank MCP - Project Brief Template v1.0.0*`,
        validationRules: [
            {
                field: 'Project Overview',
                rule: 'required',
                message: 'Project Overview section is required'
            },
            {
                field: 'Key Requirements',
                rule: 'required',
                message: 'Key Requirements section is required'
            },
            {
                field: 'Success Criteria',
                rule: 'required',
                message: 'Success Criteria section is required'
            }
        ],
        relationships: {
            requiredDependencies: [],
            optionalDependencies: [],
            influences: ['system-patterns', 'tech-context', 'active-context']
        }
    },
    'system-patterns': {
        type: 'system-patterns',
        version: '1.0.0',
        name: 'System Patterns',
        description: 'Architecture patterns, design decisions, and system structure',
        schema: {
            sections: [
                {
                    name: 'Architecture Overview',
                    description: 'High-level system architecture and design patterns',
                    required: true,
                    format: 'markdown',
                    placeholder: '## Architecture Overview\n\nDescribe the overall system architecture...'
                },
                {
                    name: 'Design Patterns',
                    description: 'Key design patterns and architectural decisions',
                    required: true,
                    format: 'markdown',
                    placeholder: '## Design Patterns\n\n### Core Patterns\n- \n\n### Architectural Decisions\n- '
                },
                {
                    name: 'Data Flow',
                    description: 'How data flows through the system',
                    required: false,
                    format: 'markdown',
                    placeholder: '## Data Flow\n\n[Describe data flow patterns and transformations]'
                },
                {
                    name: 'Integration Patterns',
                    description: 'External system integration approaches',
                    required: false,
                    format: 'markdown',
                    placeholder: '## Integration Patterns\n\n[Describe API patterns, messaging, etc.]'
                }
            ],
            requiredFields: ['Architecture Overview', 'Design Patterns'],
            optionalFields: ['Data Flow', 'Integration Patterns']
        },
        defaultContent: `# System Patterns

## Architecture Overview

[Describe the overall system architecture, key components, and their relationships]

## Design Patterns

### Core Patterns
- [List key design patterns used in the system]

### Architectural Decisions
- [Document important architectural decisions and rationale]

## Data Flow

[Describe how data flows through the system, transformations, and processing patterns]

## Integration Patterns

[Describe patterns for external system integration, APIs, messaging, etc.]

---
*Generated by MongoDB Memory Bank MCP - System Patterns Template v1.0.0*`,
        validationRules: [
            {
                field: 'Architecture Overview',
                rule: 'required',
                message: 'Architecture Overview section is required'
            },
            {
                field: 'Design Patterns',
                rule: 'required',
                message: 'Design Patterns section is required'
            }
        ],
        relationships: {
            requiredDependencies: ['project-brief'],
            optionalDependencies: ['tech-context'],
            influences: ['code-patterns', 'implementation-rules']
        }
    },
    'tech-context': {
        type: 'tech-context',
        version: '1.0.0',
        name: 'Tech Context',
        description: 'Technology stack, tools, setup instructions, and environment details',
        schema: {
            sections: [
                {
                    name: 'Technology Stack',
                    description: 'Core technologies, frameworks, and libraries',
                    required: true,
                    format: 'markdown',
                    placeholder: '## Technology Stack\n\n### Backend\n- \n\n### Frontend\n- \n\n### Database\n- '
                },
                {
                    name: 'Development Environment',
                    description: 'Setup instructions and development tools',
                    required: true,
                    format: 'markdown',
                    placeholder: '## Development Environment\n\n### Prerequisites\n- \n\n### Setup Steps\n1. '
                },
                {
                    name: 'Dependencies',
                    description: 'Key dependencies and version requirements',
                    required: false,
                    format: 'markdown',
                    placeholder: '## Dependencies\n\n### Core Dependencies\n- \n\n### Dev Dependencies\n- '
                },
                {
                    name: 'Configuration',
                    description: 'Environment variables and configuration details',
                    required: false,
                    format: 'markdown',
                    placeholder: '## Configuration\n\n### Environment Variables\n- \n\n### Config Files\n- '
                }
            ],
            requiredFields: ['Technology Stack', 'Development Environment'],
            optionalFields: ['Dependencies', 'Configuration']
        },
        defaultContent: `# Tech Context

## Technology Stack

### Backend
- [List backend technologies, frameworks, runtime]

### Frontend
- [List frontend technologies, frameworks, build tools]

### Database
- [Database technology, ORM/ODM, migration tools]

### Infrastructure
- [Deployment, hosting, CI/CD tools]

## Development Environment

### Prerequisites
- [Required software, versions, system requirements]

### Setup Steps
1. [Step-by-step setup instructions]
2. [Include installation commands]
3. [Configuration steps]

## Dependencies

### Core Dependencies
- [List major dependencies with versions]

### Dev Dependencies
- [Development and testing dependencies]

## Configuration

### Environment Variables
- [Required environment variables and their purpose]

### Config Files
- [Important configuration files and their purpose]

---
*Generated by MongoDB Memory Bank MCP - Tech Context Template v1.0.0*`,
        validationRules: [
            {
                field: 'Technology Stack',
                rule: 'required',
                message: 'Technology Stack section is required'
            },
            {
                field: 'Development Environment',
                rule: 'required',
                message: 'Development Environment section is required'
            }
        ],
        relationships: {
            requiredDependencies: ['project-brief'],
            optionalDependencies: ['system-patterns'],
            influences: ['code-patterns', 'error-solutions']
        }
    },
    'active-context': {
        type: 'active-context',
        version: '1.0.0',
        name: 'Active Context',
        description: 'Current focus, active decisions, and immediate work context',
        schema: {
            sections: [
                {
                    name: 'Current Focus',
                    description: 'What is currently being worked on',
                    required: true,
                    format: 'markdown',
                    placeholder: '## Current Focus\n\n[Describe current work focus and priorities]'
                },
                {
                    name: 'Active Decisions',
                    description: 'Recent decisions and their rationale',
                    required: true,
                    format: 'markdown',
                    placeholder: '## Active Decisions\n\n### Recent Decisions\n- \n\n### Pending Decisions\n- '
                },
                {
                    name: 'Immediate Tasks',
                    description: 'Current tasks and next steps',
                    required: false,
                    format: 'markdown',
                    placeholder: '## Immediate Tasks\n\n### In Progress\n- \n\n### Next Steps\n- '
                },
                {
                    name: 'Context Notes',
                    description: 'Important context for current work',
                    required: false,
                    format: 'markdown',
                    placeholder: '## Context Notes\n\n[Important context, assumptions, or considerations]'
                }
            ],
            requiredFields: ['Current Focus', 'Active Decisions'],
            optionalFields: ['Immediate Tasks', 'Context Notes']
        },
        defaultContent: `# Active Context

## Current Focus

[Describe what is currently being worked on, main priorities, and focus areas]

## Active Decisions

### Recent Decisions
- [List recent important decisions with rationale]

### Pending Decisions
- [Decisions that need to be made soon]

## Immediate Tasks

### In Progress
- [Tasks currently being worked on]

### Next Steps
- [Immediate next actions and priorities]

## Context Notes

[Important context, assumptions, constraints, or considerations for current work]

---
*Generated by MongoDB Memory Bank MCP - Active Context Template v1.0.0*
*Last Updated: ${new Date().toISOString().split('T')[0]}*`,
        validationRules: [
            {
                field: 'Current Focus',
                rule: 'required',
                message: 'Current Focus section is required'
            },
            {
                field: 'Active Decisions',
                rule: 'required',
                message: 'Active Decisions section is required'
            }
        ],
        relationships: {
            requiredDependencies: ['project-brief'],
            optionalDependencies: ['system-patterns', 'tech-context'],
            influences: ['progress-tracking', 'implementation-rules']
        }
    },
    'progress-tracking': {
        type: 'progress-tracking',
        version: '1.0.0',
        name: 'Progress Tracking',
        description: 'Project status, milestones, roadmap, and progress metrics',
        schema: {
            sections: [
                {
                    name: 'Current Status',
                    description: 'Overall project status and health',
                    required: true,
                    format: 'markdown',
                    placeholder: '## Current Status\n\n**Status**: [In Progress/On Track/At Risk/Complete]\n**Progress**: [X]% complete'
                },
                {
                    name: 'Completed Milestones',
                    description: 'Achieved milestones and deliverables',
                    required: true,
                    format: 'markdown',
                    placeholder: '## Completed Milestones\n\n- ✅ [Milestone 1] - [Date]\n- ✅ [Milestone 2] - [Date]'
                },
                {
                    name: 'Upcoming Milestones',
                    description: 'Planned milestones and target dates',
                    required: false,
                    format: 'markdown',
                    placeholder: '## Upcoming Milestones\n\n- 🎯 [Milestone] - [Target Date]\n- 🎯 [Milestone] - [Target Date]'
                },
                {
                    name: 'Roadmap',
                    description: 'High-level roadmap and timeline',
                    required: false,
                    format: 'markdown',
                    placeholder: '## Roadmap\n\n### Phase 1: [Name]\n- [Timeline]\n- [Key deliverables]'
                }
            ],
            requiredFields: ['Current Status', 'Completed Milestones'],
            optionalFields: ['Upcoming Milestones', 'Roadmap']
        },
        defaultContent: `# Progress Tracking

## Current Status

**Status**: [In Progress/On Track/At Risk/Complete]
**Progress**: [X]% complete
**Last Updated**: ${new Date().toISOString().split('T')[0]}

[Brief description of current project health and status]

## Completed Milestones

- ✅ [Milestone 1] - [Date] - [Brief description]
- ✅ [Milestone 2] - [Date] - [Brief description]

## Upcoming Milestones

- 🎯 [Next Milestone] - [Target Date] - [Description]
- 🎯 [Future Milestone] - [Target Date] - [Description]

## Roadmap

### Phase 1: [Phase Name]
- **Timeline**: [Start Date] - [End Date]
- **Key Deliverables**: [List main deliverables]
- **Status**: [Not Started/In Progress/Complete]

### Phase 2: [Phase Name]
- **Timeline**: [Start Date] - [End Date]
- **Key Deliverables**: [List main deliverables]
- **Status**: [Not Started/In Progress/Complete]

## Metrics

- **Features Completed**: [X] / [Total]
- **Tests Passing**: [X]%
- **Code Coverage**: [X]%
- **Performance**: [Meeting/Not Meeting] targets

---
*Generated by MongoDB Memory Bank MCP - Progress Tracking Template v1.0.0*`,
        validationRules: [
            {
                field: 'Current Status',
                rule: 'required',
                message: 'Current Status section is required'
            },
            {
                field: 'Completed Milestones',
                rule: 'required',
                message: 'Completed Milestones section is required'
            }
        ],
        relationships: {
            requiredDependencies: ['active-context'],
            optionalDependencies: ['project-brief'],
            influences: []
        }
    },
    'code-patterns': {
        type: 'code-patterns',
        version: '1.0.0',
        name: 'Code Patterns',
        description: 'Code structure, conventions, patterns, and best practices',
        schema: {
            sections: [
                {
                    name: 'Code Structure',
                    description: 'Project structure and organization patterns',
                    required: true,
                    format: 'markdown',
                    placeholder: '## Code Structure\n\n### Directory Structure\n```\n/src\n  /components\n  /services\n```'
                },
                {
                    name: 'Coding Conventions',
                    description: 'Naming conventions, style guidelines, and standards',
                    required: true,
                    format: 'markdown',
                    placeholder: '## Coding Conventions\n\n### Naming Conventions\n- \n\n### Style Guidelines\n- '
                },
                {
                    name: 'Common Patterns',
                    description: 'Frequently used code patterns and implementations',
                    required: false,
                    format: 'markdown',
                    placeholder: '## Common Patterns\n\n### Design Patterns\n- \n\n### Implementation Patterns\n- '
                },
                {
                    name: 'Best Practices',
                    description: 'Established best practices and guidelines',
                    required: false,
                    format: 'markdown',
                    placeholder: '## Best Practices\n\n### Code Quality\n- \n\n### Performance\n- '
                }
            ],
            requiredFields: ['Code Structure', 'Coding Conventions'],
            optionalFields: ['Common Patterns', 'Best Practices']
        },
        defaultContent: `# Code Patterns

## Code Structure

### Directory Structure
\`\`\`
[Describe the project directory structure and organization]
\`\`\`

### Module Organization
- [Describe how modules/components are organized]
- [Explain the separation of concerns]

## Coding Conventions

### Naming Conventions
- **Files**: [File naming patterns]
- **Functions**: [Function naming patterns]
- **Variables**: [Variable naming patterns]
- **Classes**: [Class naming patterns]

### Style Guidelines
- [Code formatting standards]
- [Comment conventions]
- [Import/export patterns]

## Common Patterns

### Design Patterns
- [List commonly used design patterns with examples]

### Implementation Patterns
- [Common implementation approaches and patterns]

### Error Handling
- [Standard error handling patterns]

## Best Practices

### Code Quality
- [Code quality guidelines and standards]
- [Testing requirements]
- [Documentation standards]

### Performance
- [Performance optimization guidelines]
- [Resource management patterns]

### Security
- [Security best practices and patterns]

---
*Generated by MongoDB Memory Bank MCP - Code Patterns Template v1.0.0*`,
        validationRules: [
            {
                field: 'Code Structure',
                rule: 'required',
                message: 'Code Structure section is required'
            },
            {
                field: 'Coding Conventions',
                rule: 'required',
                message: 'Coding Conventions section is required'
            }
        ],
        relationships: {
            requiredDependencies: ['tech-context'],
            optionalDependencies: ['system-patterns'],
            influences: ['implementation-rules', 'error-solutions']
        }
    },
    'error-solutions': {
        type: 'error-solutions',
        version: '1.0.0',
        name: 'Error Solutions',
        description: 'Common errors, troubleshooting guides, and solution patterns',
        schema: {
            sections: [
                {
                    name: 'Common Errors',
                    description: 'Frequently encountered errors and their solutions',
                    required: true,
                    format: 'markdown',
                    placeholder: '## Common Errors\n\n### Error: [Error Name]\n**Symptoms**: \n**Cause**: \n**Solution**: '
                },
                {
                    name: 'Troubleshooting Guide',
                    description: 'Step-by-step troubleshooting procedures',
                    required: true,
                    format: 'markdown',
                    placeholder: '## Troubleshooting Guide\n\n### Problem Category\n1. [Step 1]\n2. [Step 2]'
                },
                {
                    name: 'Error Patterns',
                    description: 'Patterns in errors and systematic solutions',
                    required: false,
                    format: 'markdown',
                    placeholder: '## Error Patterns\n\n### Pattern: [Pattern Name]\n**Description**: \n**Prevention**: '
                },
                {
                    name: 'Prevention Strategies',
                    description: 'Strategies to prevent common issues',
                    required: false,
                    format: 'markdown',
                    placeholder: '## Prevention Strategies\n\n- [Strategy 1]\n- [Strategy 2]'
                }
            ],
            requiredFields: ['Common Errors', 'Troubleshooting Guide'],
            optionalFields: ['Error Patterns', 'Prevention Strategies']
        },
        defaultContent: `# Error Solutions

## Common Errors

### Error: [Error Name/Type]
**Symptoms**: [How the error manifests]
**Cause**: [Root cause of the error]
**Solution**: [Step-by-step solution]
**Prevention**: [How to prevent this error]

### Error: [Another Error Name/Type]
**Symptoms**: [How the error manifests]
**Cause**: [Root cause of the error]
**Solution**: [Step-by-step solution]
**Prevention**: [How to prevent this error]

## Troubleshooting Guide

### Build/Compilation Issues
1. [Check step 1]
2. [Check step 2]
3. [Resolution steps]

### Runtime Errors
1. [Diagnostic step 1]
2. [Diagnostic step 2]
3. [Resolution approach]

### Performance Issues
1. [Performance diagnostic steps]
2. [Common causes to check]
3. [Optimization approaches]

## Error Patterns

### Pattern: [Pattern Name]
**Description**: [Description of the error pattern]
**Common Causes**: [What typically causes this pattern]
**Prevention**: [How to prevent this pattern]

## Prevention Strategies

- [Strategy 1: Description and implementation]
- [Strategy 2: Description and implementation]
- [Strategy 3: Description and implementation]

## Debugging Tools

### Recommended Tools
- [Tool 1]: [Purpose and usage]
- [Tool 2]: [Purpose and usage]

### Debugging Techniques
- [Technique 1]: [When and how to use]
- [Technique 2]: [When and how to use]

---
*Generated by MongoDB Memory Bank MCP - Error Solutions Template v1.0.0*`,
        validationRules: [
            {
                field: 'Common Errors',
                rule: 'required',
                message: 'Common Errors section is required'
            },
            {
                field: 'Troubleshooting Guide',
                rule: 'required',
                message: 'Troubleshooting Guide section is required'
            }
        ],
        relationships: {
            requiredDependencies: ['tech-context'],
            optionalDependencies: ['code-patterns'],
            influences: ['implementation-rules']
        }
    },
    'implementation-rules': {
        type: 'implementation-rules',
        version: '1.0.0',
        name: 'Implementation Rules',
        description: 'AI behavior patterns, implementation guidelines, and decision rules (.clinerules equivalent)',
        schema: {
            sections: [
                {
                    name: 'AI Behavior Rules',
                    description: 'Rules for AI assistant behavior and decision making',
                    required: true,
                    format: 'markdown',
                    placeholder: '## AI Behavior Rules\n\n### Code Generation\n- \n\n### Decision Making\n- '
                },
                {
                    name: 'Implementation Guidelines',
                    description: 'Guidelines for implementing features and changes',
                    required: true,
                    format: 'markdown',
                    placeholder: '## Implementation Guidelines\n\n### Feature Development\n- \n\n### Code Changes\n- '
                },
                {
                    name: 'Decision Patterns',
                    description: 'Patterns for making technical decisions',
                    required: false,
                    format: 'markdown',
                    placeholder: '## Decision Patterns\n\n### Technology Choices\n- \n\n### Architecture Decisions\n- '
                },
                {
                    name: 'Workflow Rules',
                    description: 'Rules for development workflow and processes',
                    required: false,
                    format: 'markdown',
                    placeholder: '## Workflow Rules\n\n### Development Process\n- \n\n### Testing Requirements\n- '
                }
            ],
            requiredFields: ['AI Behavior Rules', 'Implementation Guidelines'],
            optionalFields: ['Decision Patterns', 'Workflow Rules']
        },
        defaultContent: `# Implementation Rules

## AI Behavior Rules

### Code Generation
- Always follow established code patterns and conventions
- Prioritize readability and maintainability over cleverness
- Include comprehensive error handling and validation
- Generate tests alongside implementation code
- Document complex logic and decisions

### Decision Making
- Prefer established patterns over novel approaches
- Consider performance implications of all decisions
- Validate assumptions with existing codebase patterns
- Seek clarification for ambiguous requirements
- Document rationale for significant decisions

### Memory Bank Usage
- Always read relevant memories before making changes
- Update memories when patterns or decisions change
- Maintain consistency with established project context
- Reference related memories in implementation

## Implementation Guidelines

### Feature Development
- Start with clear requirements and acceptance criteria
- Design interfaces before implementation
- Implement with backward compatibility in mind
- Include comprehensive testing strategy
- Document public APIs and complex logic

### Code Changes
- Maintain existing code style and patterns
- Preserve backward compatibility unless explicitly breaking
- Update related documentation and tests
- Consider impact on dependent components
- Follow established review and approval processes

### Error Handling
- Use consistent error handling patterns
- Provide meaningful error messages
- Log appropriate level of detail for debugging
- Handle edge cases gracefully
- Implement proper fallback mechanisms

## Decision Patterns

### Technology Choices
- Prefer technologies already in use in the project
- Evaluate new technologies against established criteria
- Consider long-term maintenance and support
- Assess team expertise and learning curve
- Document technology decisions and rationale

### Architecture Decisions
- Follow established architectural patterns
- Consider scalability and performance implications
- Maintain separation of concerns
- Design for testability and maintainability
- Document architectural decisions and trade-offs

## Workflow Rules

### Development Process
- Follow established branching and merging strategies
- Ensure all tests pass before merging
- Conduct code reviews for all changes
- Update documentation with code changes
- Maintain clean commit history

### Testing Requirements
- Write unit tests for all new functionality
- Maintain or improve test coverage
- Include integration tests for complex features
- Test error conditions and edge cases
- Update tests when changing existing functionality

### Quality Standards
- Code must pass all linting and formatting checks
- Performance must meet established benchmarks
- Security considerations must be addressed
- Accessibility requirements must be met
- Documentation must be complete and accurate

---
*Generated by MongoDB Memory Bank MCP - Implementation Rules Template v1.0.0*
*This serves as the .clinerules equivalent for AI behavior patterns*`,
        validationRules: [
            {
                field: 'AI Behavior Rules',
                rule: 'required',
                message: 'AI Behavior Rules section is required'
            },
            {
                field: 'Implementation Guidelines',
                rule: 'required',
                message: 'Implementation Guidelines section is required'
            }
        ],
        relationships: {
            requiredDependencies: ['code-patterns'],
            optionalDependencies: ['system-patterns', 'error-solutions'],
            influences: []
        }
    },
    'custom': {
        type: 'custom',
        version: '1.0.0',
        name: 'Custom Template',
        description: 'User-defined custom memory template',
        schema: {
            sections: [
                {
                    name: 'Content',
                    description: 'Custom content section',
                    required: true,
                    format: 'markdown',
                    placeholder: '## Custom Content\n\n[Add your custom content here]'
                }
            ],
            requiredFields: ['Content'],
            optionalFields: []
        },
        defaultContent: `# Custom Memory

## Content

[Add your custom content here]

---
*Generated by MongoDB Memory Bank MCP - Custom Template v1.0.0*`,
        validationRules: [
            {
                field: 'Content',
                rule: 'required',
                message: 'Content section is required'
            }
        ],
        relationships: {
            requiredDependencies: [],
            optionalDependencies: [],
            influences: []
        }
    }
};
/**
 * Template hierarchy levels for relationship management
 */
export const TEMPLATE_HIERARCHY = {
    'project-brief': 0, // Foundation level
    'system-patterns': 0, // Foundation level
    'tech-context': 0, // Foundation level
    'active-context': 1, // Active level
    'code-patterns': 1, // Active level
    'error-solutions': 1, // Active level
    'implementation-rules': 1, // Active level
    'progress-tracking': 2, // Tracking level
    'custom': 1 // Active level (default)
};
/**
 * Get template by type
 */
export function getTemplate(type) {
    return CORE_MEMORY_TEMPLATES[type];
}
/**
 * Get all available template types
 */
export function getAvailableTemplateTypes() {
    return Object.keys(CORE_MEMORY_TEMPLATES);
}
/**
 * Get templates by hierarchy level
 */
export function getTemplatesByLevel(level) {
    return Object.entries(TEMPLATE_HIERARCHY)
        .filter(([_, templateLevel]) => templateLevel === level)
        .map(([type, _]) => type);
}