Module Component Generator

Module/Component Generator

Generate complete, production-ready modules and components from interface contracts and specifications.

Quick Start

When a user provides an interface contract or requests a module:

1. Understand the contract: Analyze the interface, abstract class, or specification
2. Determine scope: Clarify if generating single implementation or full module
3. Select patterns: Choose appropriate design patterns and structure
4. Generate code: Create implementation with proper structure and documentation
5. Add documentation: Include comprehensive docstrings and usage examples

What This Skill Generates

Interface Implementations

Generate concrete implementations from:

• Python Protocols and Abstract Base Classes
• Java interfaces and abstract classes
• Complete with validation, error handling, and documentation

Complete Modules

Generate multi-file modules with:

• Domain models
• Repository/data access layer
• Service/business logic layer
• Custom exceptions
• Comprehensive documentation

Documentation

Generate for all code:

• Module-level documentation
• Class and method docstrings
• Usage examples
• API reference documentation

Generation Scope

Single Interface Implementation

When to use:

• User provides a single interface/protocol/abstract class
• Need one concrete implementation
• Simple, focused functionality

What to generate:

• Implementation class with all required methods
• Input validation
• Error handling
• Docstrings with examples
• Basic usage example

Full Module Generation

When to use:

• Building a complete feature or service
• Need multiple related classes
• Require layered architecture (model, repository, service)

What to generate:

• Domain models with validation
• Repository layer for data access
• Service layer for business logic
• Custom exception hierarchy
• Module-level documentation
• Complete usage examples

Language-Specific Guidance

Python

Patterns and conventions:

• Use type hints for all parameters and returns
• Use Protocol for structural typing
• Use ABC for inheritance-based contracts
• Follow PEP 8 style guidelines
• Use dataclasses or Pydantic for models

See: python-patterns.md for detailed examples

Common structures:

• Protocol implementation
• ABC implementation
• Service layer module (model + repository + service)
• Adapter pattern module
• Factory pattern module

Java

Patterns and conventions:

• Implement interfaces explicitly
• Use Objects.requireNonNull() for validation
• Use Optional<T> for nullable returns
• Follow Java naming conventions
• Use proper exception hierarchy

See: java-patterns.md for detailed examples

Common structures:

• Interface implementation
• Abstract class extension
• Service layer module (model + repository + service)
• Strategy pattern module
• Builder pattern module

Workflow

1. Analyze the Contract

For interfaces/protocols:

• Identify all methods that need implementation
• Note parameter types and return types
• Check for any constraints or requirements
• Understand the intended behavior

For module requests:

• Identify core entities/models
• Determine required operations (CRUD, business logic)
• Understand relationships between components
• Clarify persistence requirements

2. Determine Structure

Single implementation:

• One class implementing the interface
• Helper methods if needed
• Validation and error handling

Full module:

• Domain models (data structures)
• Repository layer (data access)
• Service layer (business logic)
• Exception classes (error handling)
• Module initialization

3. Generate Implementation

For each class:

1. Write class declaration with proper inheritance
2. Implement constructor with dependency injection
3. Implement all required methods
4. Add validation and error handling
5. Add helper methods if needed
6. Write comprehensive docstrings

Code quality standards:

• Validate all inputs
• Handle edge cases
• Use meaningful variable names
• Follow language conventions
• Keep methods focused and small

4. Add Documentation

Module level:

• Overview of module purpose
• List of main classes
• Usage examples
• See documentation-patterns.md

Class level:

• Purpose and responsibility
• Constructor parameters
• Key methods overview
• Usage examples

Method level:

• What the method does
• Parameters and types
• Return value and type
• Exceptions that can be raised
• Usage example for complex methods

5. Provide Usage Examples

Include:

• Basic usage example
• Common use cases
• Error handling examples
• Integration examples for modules

Design Patterns