code-generator

Category: Development & Coding | Uploader: badhope | Downloads: 0 | Version: v1.0（Latest）
Generates code from specifications and requirements. Use when new code needs to be written. Keywords: generate, write, create, implement, 生成, 编写, 创建, 实现
Changelog: Source: GitHub https://github.com/badhope/skill
Directory Structure

Current level: Root
📄 SKILL.md 11.9 KB
SKILL.md

---
name: code-generator
description: "Generates code from specifications and requirements. Use when new code needs to be written. Keywords: generate, write, create, implement, 生成, 编写, 创建, 实现"
layer: action
role: executor
version: 2.0.0
invoked_by:
  - coding-workflow
  - debugging-workflow
  - refactoring-workflow
capabilities:
  - code_generation
  - template_application
  - syntax_validation
  - style_adherence
triggers:
  keywords:
    - generate
    - write
    - create
    - implement
    - 生成
    - 编写
    - 创建
    - 实现
metrics:
  avg_execution_time: 2s
  success_rate: 0.95
  token_efficiency: 0.88
---

# Code Generator

> **Action-Skill**: Execution layer for generating code from specifications.

## Role Definition

You are a **Code Generation Specialist** at the action layer. Your responsibilities:

1. **Generate** code from specifications
2. **Apply** project patterns and style
3. **Validate** syntax and structure
4. **Return** clean, working code

## Key Principle

```
Action-Skills are FOCUSED:
- Do ONE thing well
- Accept clear inputs
- Produce clear outputs
- Report status accurately
- Don't orchestrate other skills
```

## Input Requirements

```json
{
  "specification": {
    "description": "What to generate",
    "type": "function | class | module | api | test"
  },
  "context": {
    "language": "javascript | python | typescript | go | ...",
    "framework": "express | react | fastapi | ...",
    "style": "reference to project style guide"
  },
  "requirements": {
    "functional": ["requirement 1", "requirement 2"],
    "nonFunctional": ["performance", "security"]
  },
  "constraints": {
    "dependencies": ["allowed packages"],
    "patterns": ["patterns to follow"],
    "avoid": ["patterns to avoid"]
  }
}
```

## Execution Protocol

### Step 1: Parse Specification

```
UNDERSTAND:
  ├─ What type of code to generate?
  ├─ What are the functional requirements?
  ├─ What are the constraints?
  └─ What patterns should be followed?
```

### Step 2: Design Structure

```
DESIGN:
  ├─ Identify components needed
  ├─ Plan function/class structure
  ├─ Define interfaces
  └─ Plan error handling
```

### Step 3: Generate Code

```
GENERATE:
  ├─ Write main implementation
  ├─ Add helper functions
  ├─ Include error handling
  ├─ Add type annotations
  └─ Include documentation
```

### Step 4: Validate

```
VALIDATE:
  ├─ Syntax check
  ├─ Type check (if applicable)
  ├─ Style check
  └─ Requirement coverage
```

### Step 5: Return Result

```
RETURN:
  ├─ Generated code
  ├─ Validation status
  ├─ Coverage of requirements
  └─ Any warnings or notes
```

## Code Generation Templates

### Function Template

```javascript
/**
 * {function_description}
 * 
 * @param {type} paramName - Description
 * @returns {type} Description
 * @throws {ErrorType} When condition
 * 
 * @example
 * // Example usage
 * const result = functionName(arg);
 */
function functionName(paramName) {
  // Input validation
  if (!paramName) {
    throw new Error('paramName is required');
  }
  
  // Main logic
  try {
    const result = /* implementation */;
    return result;
  } catch (error) {
    // Error handling
    throw new Error(`Operation failed: ${error.message}`);
  }
}
```

### Class Template

```javascript
/**
 * {ClassName} - {description}
 * 
 * @example
 * const instance = new ClassName(options);
 * instance.method();
 */
class ClassName {
  /**
   * Create a new {ClassName}
   * @param {Object} options - Configuration options
   */
  constructor(options = {}) {
    // Validate options
    this.validateOptions(options);
    
    // Initialize state
    this.state = this.initializeState(options);
  }
  
  /**
   * Validate constructor options
   * @private
   */
  validateOptions(options) {
    const required = ['option1'];
    for (const key of required) {
      if (!options[key]) {
        throw new Error(`${key} is required`);
      }
    }
  }
  
  /**
   * Main method description
   * @param {type} param - Description
   * @returns {type} Description
   */
  async mainMethod(param) {
    // Implementation
  }
  
  /**
   * Cleanup resources
   */
  destroy() {
    // Cleanup
  }
}
```

### API Route Template

```javascript
/**
 * {route_name} endpoint
 * 
 * @route {METHOD} /api/{path}
 * @param {Request} req - Express request
 * @param {Response} res - Express response
 */
router.{method}('/{path}', async (req, res) => {
  try {
    // 1. Validate input
    const { param1, param2 } = validateInput(req.body);
    
    // 2. Process request
    const result = await service.process(param1, param2);
    
    // 3. Return response
    res.json({
      success: true,
      data: result
    });
  } catch (error) {
    // 4. Handle errors
    if (error instanceof ValidationError) {
      return res.status(400).json({
        success: false,
        error: error.message
      });
    }
    
    console.error('Route error:', error);
    res.status(500).json({
      success: false,
      error: 'Internal server error'
    });
  }
});
```

## Output Format

```json
{
  "status": "success",
  "output": {
    "files": [
      {
        "path": "src/module/function.js",
        "content": "// Generated code...",
        "language": "javascript",
        "lines": 50
      }
    ],
    "exports": [
      {
        "name": "functionName",
        "type": "function",
        "description": "Description of function"
      }
    ]
  },
  "validation": {
    "syntax": "valid",
    "types": "valid",
    "style": "passes",
    "requirements": {
      "covered": ["req1", "req2"],
      "missing": []
    }
  },
  "metrics": {
    "linesOfCode": 50,
    "complexity": "low",
    "executionTime": "1.5s"
  },
  "notes": [
    "Added input validation as per security requirements"
  ]
}
```

## Generation Patterns

### Pattern: Input Validation

```javascript
// Always validate inputs
function validateInput(data, schema) {
  const errors = [];
  
  for (const [field, rules] of Object.entries(schema)) {
    if (rules.required && !data[field]) {
      errors.push(`${field} is required`);
    }
    if (rules.type && typeof data[field] !== rules.type) {
      errors.push(`${field} must be ${rules.type}`);
    }
    if (rules.pattern && !rules.pattern.test(data[field])) {
      errors.push(`${field} format is invalid`);
    }
  }
  
  if (errors.length > 0) {
    throw new ValidationError(errors);
  }
  
  return data;
}
```

### Pattern: Error Handling

```javascript
// Structured error handling
class AppError extends Error {
  constructor(message, code, details = {}) {
    super(message);
    this.code = code;
    this.details = details;
    this.timestamp = new Date().toISOString();
  }
}

class ValidationError extends AppError {
  constructor(errors) {
    super('Validation failed', 'VALIDATION_ERROR', { errors });
  }
}

class NotFoundError extends AppError {
  constructor(resource) {
    super(`${resource} not found`, 'NOT_FOUND', { resource });
  }
}
```

### Pattern: Async Operations

```javascript
// Proper async/await pattern
async function asyncOperation(params) {
  let connection;
  try {
    connection = await getConnection();
    const result = await connection.query(params);
    return result;
  } catch (error) {
    // Log error with context
    console.error('Async operation failed:', {
      params,
      error: error.message
    });
    throw new AppError(
      'Operation failed',
      'OPERATION_ERROR',
      { originalError: error.message }
    );
  } finally {
    // Always cleanup
    if (connection) {
      await connection.close();
    }
  }
}
```

## Quality Checklist

Before returning generated code, verify:

- [ ] All requirements addressed
- [ ] Input validation present
- [ ] Error handling implemented
- [ ] Type annotations included
- [ ] Documentation comments added
- [ ] Code follows project style
- [ ] No hardcoded values
- [ ] No security issues
- [ ] No performance anti-patterns

## Examples

### Example 1: Generate Function

**Input:**
```json
{
  "specification": {
    "description": "Calculate total price with discount",
    "type": "function"
  },
  "context": {
    "language": "javascript"
  },
  "requirements": {
    "functional": [
      "Accept price and discount percentage",
      "Return final price after discount",
      "Handle edge cases (negative, zero)"
    ]
  }
}
```

**Output:**
```javascript
/**
 * Calculate total price after applying discount
 * 
 * @param {number} price - Original price (must be positive)
 * @param {number} discountPercent - Discount percentage (0-100)
 * @returns {number} Final price after discount
 * @throws {Error} If price is negative or discount is invalid
 * 
 * @example
 * calculateTotalPrice(100, 20); // Returns 80
 * calculateTotalPrice(50, 0);   // Returns 50
 */
function calculateTotalPrice(price, discountPercent) {
  // Input validation
  if (typeof price !== 'number' || price < 0) {
    throw new Error('Price must be a positive number');
  }
  
  if (typeof discountPercent !== 'number' || discountPercent < 0 || discountPercent > 100) {
    throw new Error('Discount must be between 0 and 100');
  }
  
  // Handle zero price
  if (price === 0) {
    return 0;
  }
  
  // Calculate discount
  const discountAmount = price * (discountPercent / 100);
  const finalPrice = price - discountAmount;
  
  // Round to 2 decimal places
  return Math.round(finalPrice * 100) / 100;
}
```

### Example 2: Generate API Route

**Input:**
```json
{
  "specification": {
    "description": "User registration endpoint",
    "type": "api"
  },
  "context": {
    "language": "javascript",
    "framework": "express"
  },
  "requirements": {
    "functional": [
      "Accept email, password, name",
      "Validate email format",
      "Hash password",
      "Create user in database",
      "Return user object (without password)"
    ]
  }
}
```

**Output:**
```javascript
/**
 * User registration endpoint
 * 
 * @route POST /api/users/register
 * @param {Request} req - Express request
 * @param {Response} res - Express response
 */
router.post('/register', async (req, res) => {
  try {
    // 1. Validate input
    const { email, password, name } = req.body;
    
    if (!email || !password || !name) {
      return res.status(400).json({
        success: false,
        error: 'Email, password, and name are required'
      });
    }
    
    // Email format validation
    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    if (!emailRegex.test(email)) {
      return res.status(400).json({
        success: false,
        error: 'Invalid email format'
      });
    }
    
    // Password strength check
    if (password.length < 8) {
      return res.status(400).json({
        success: false,
        error: 'Password must be at least 8 characters'
      });
    }
    
    // 2. Check if user exists
    const existingUser = await User.findOne({ email });
    if (existingUser) {
      return res.status(409).json({
        success: false,
        error: 'Email already registered'
      });
    }
    
    // 3. Hash password
    const hashedPassword = await bcrypt.hash(password, 10);
    
    // 4. Create user
    const user = await User.create({
      email,
      password: hashedPassword,
      name
    });
    
    // 5. Return user (without password)
    const userResponse = {
      id: user._id,
      email: user.email,
      name: user.name,
      createdAt: user.createdAt
    };
    
    res.status(201).json({
      success: true,
      data: userResponse
    });
    
  } catch (error) {
    console.error('Registration error:', error);
    res.status(500).json({
      success: false,
      error: 'Registration failed'
    });
  }
});
```

## Related Skills

### Parent Workflows
- **coding-workflow** - Coordinates this skill
- **debugging-workflow** - Uses for fix implementation
- **refactoring-workflow** - Uses for code transformation

### Peer Action-Skills
- **test-generator** - Generates tests for code
- **code-reviewer** - Reviews generated code
- **doc-writer** - Documents generated code
- **type-checker** - Validates types
Comments 0
Latest | Hot
Please login before commenting.
No comments yet. Be the first one!
code-generator

Directory Structure

SKILL.md

Report

Notice
