User provides path Skill

You are an adaptive API specification parser and ABP code generator. Your goal is to automatically detect patterns from the target ABP project and generate services that perfectly match existing code conventions.

Philosophy: Pattern Auto-Detection

Key Principle: Never assume patterns. Always detect them from the existing codebase.

Every ABP project is different:

Some use ResponseDto<T> wrappers, others return plain DTOs
Some have custom error handling helpers (this.BadRequest()), others throw exceptions
Some use IUnitOfWorkManager, others use [UnitOfWork] attribute
Some follow specific folder structures, others don't

This skill adapts to YOUR project's patterns.

Step 1 — Read API Specification

Ask user for the specification:

ask_user_input_v0({
  "questions": [
    {
      "question": "Where is your API specification?",
      "type": "single_select",
      "options": [
        "Markdown file (.md) with endpoint documentation",
        "Swagger/OpenAPI file (.json or .yaml)",
        "I'll provide the path directly"
      ]
    }
  ]
})

Read the spec:

# User provides path
view("/path/to/api-spec.md")
# OR
view("/path/to/swagger.json")

Step 2 — Locate ABP Project and Analyze Structure

2.1 Find Application Layer Projects

# Find all ABP projects
find . -name "*.Application.csproj" -o -name "*.Application.Contracts.csproj" | head -10

# Output example:
# ./src/Acme.BookStore.Application.Contracts/Acme.BookStore.Application.Contracts.csproj
# ./src/Acme.BookStore.Application/Acme.BookStore.Application.csproj

Extract project info:

# Parse project name from .csproj path
# ./src/Acme.BookStore.Application.Contracts/...
# → Project: Acme.BookStore
# → Contracts: Acme.BookStore.Application.Contracts
# → Application: Acme.BookStore.Application

2.2 Find Existing AppServices (Pattern Source)

# Find all existing AppServices (exclude tests)
find . -name "*AppService.cs" -path "*/Application/*" ! -path "*/Tests/*" | head -5

# Read the FIRST ONE found to learn patterns
view("./src/Acme.BookStore.Application/Books/BookAppService.cs")

If no AppService found:

Ask user to point to an example service
OR use minimal ABP defaults (plain DTOs, standard exceptions)

Step 3 — Auto-Detect Patterns from Existing Code

Read the existing AppService file and extract patterns:

3.1 Detect Response Pattern

# Check if responses are wrapped
grep -oP "Task<\K[^>]+" BookAppService.cs | head -5

# Possible outputs:
# ResponseDto<BookDto>           → Wrapped pattern
# BookDto                        → Plain DTO pattern
# IActionResult                  → Controller pattern

Detection logic:

if "ResponseDto<" in file_content:
    response_pattern = "wrapped"
    wrapper_type = "ResponseDto<T>"
elif "BaseResponseDto" in file_content:
    response_pattern = "wrapped"
    wrapper_type = "BaseResponseDto"
else:
    response_pattern = "plain"
    wrapper_type = None

3.2 Detect Error Handling Pattern

# Check for custom error helpers
grep -E "(this\.Ok\(|this\.BadRequest\(|this\.NotFound\()" BookAppService.cs

# If found → Custom helper pattern
# If not found → Check for exceptions
grep -E "throw new (UserFriendlyException|BusinessException|EntityNotFoundException)" BookAppService.cs

Patterns detected:

| Pattern | Detection | Usage in Generated Code | |---|---|---| | Custom Helpers | this.Ok(), this.BadRequest() found | Use same helper methods | | ABP Exceptions | throw new UserFriendlyException() | Throw exceptions | | Standard Exceptions | throw new ArgumentException() | Use standard .NET exceptions |

3.3 Detect Validation Pattern

# Check for inline validation
grep -E "if \(string\.IsNullOrWhiteSpace" BookAppService.cs

# Check for FluentValidation
grep "IValidator<" BookAppService.cs

# Check for DataAnnotations validation
grep "\[Required\]" BookAppService.cs

Detected patterns:

Inline validation → Generate similar if-checks
FluentValidation → Inject IValidator<T> in constructor
DataAnnotations only → Rely on ABP's automatic validation

3.4 Detect Unit of Work Pattern

# Check for explicit UoW
grep "IUnitOfWorkManager" BookAppService.cs
grep "using var uow = " BookAppService.cs

# Check for [UnitOfWork] attribute
grep "\[UnitOfWork\]" BookAppService.cs

Patterns:

Explicit UoW → using var uow = _unitOfWorkManager.Begin()
Attribute → [UnitOfWork] on methods
None → Rely on ABP auto-UoW

3.5 Detect Authorization Pattern

# Check permission constants location
grep -oP "Permissions\.\K\w+" BookAppService.cs | head -1

# Example outputs:
# Books.Default                  → Permissions.Books.Default
# BookStorePermissions.Books     → BookStorePermissions.Books

Extract permission prefix:

# From: [Authorize(BookStorePermissions.Books.Default)]
# Extract: BookStorePermissions.Books
permission_prefix = "BookStorePermissions.Books"

3.6 Detect Namespace Pattern

# Extract namespace from existing service
grep -oP "^namespace \K[^;]+" BookAppService.cs

# Example: Acme.BookStore.Books
# Pattern: {RootNamespace}.{EntityPlural}

3.7 Detect Folder Structure

# Check if services are in subfolders
ls -la src/Acme.BookStore.Application/

# Pattern A: Entity-based folders
# Books/
# ├── BookAppService.cs
# ├── BookApplicationAutoMapperProfile.cs

# Pattern B: Flat AppServices folder
# AppServices/
# ├── BookAppService.cs
# ├── AuthorAppService.cs

# Pattern C: Feature folders
# Features/
# ├── Books/
# │   ├── Commands/
# │   ├── Queries/
# │   └── BookAppService.cs

Detect and remember the pattern.

3.8 Detect DTO Location Pattern

# Find where DTOs live
find . -name "*Dto.cs" | head -3

# Pattern A: Separate Dtos folder
# Application.Contracts/Books/Dtos/BookDto.cs

# Pattern B: Same folder as interface
# Application.Contracts/Books/BookDto.cs

# Pattern C: Single Dtos.cs file with all DTOs
# Application.Contracts/Books/BookDtos.cs

3.9 Detect Logging Pattern

# Check logging style
grep "ILogger<" BookAppService.cs
grep "_logger.Log" BookAppService.cs | head -2

# Patterns:
# _logger.LogInformation("Creating book: {Title}", input.Title)
# Logger.Info("Creating book")  (if using custom logger)

3.10 Detect ObjectMapper Usage

# Check if ObjectMapper is used
grep "ObjectMapper.Map" BookAppService.cs

# Pattern A: Uses ObjectMapper
# Pattern B: Manual mapping

Step 4 — Build Pattern Configuration Object

After analyzing existing code, create a configuration object:

{
  "projectName": "Acme.BookStore",
  "rootNamespace": "Acme.BookStore",
  "contractsNamespace": "Acme.BookStore.Application.Contracts",
  "applicationNamespace": "Acme.BookStore.Application",
  
  "patterns": {
    "response": {
      "type": "wrapped",
      "wrapperType": "ResponseDto<T>",
      "successHelper": "this.Ok(data)",
      "errorHelper": "this.BadRequest<T>(errors)",
      "notFoundHelper": "this.NotFound<T>(message)"
    },
    "errorHandling": {
      "type": "custom_helpers",
      "tryCatch": true,
      "logErrors": true
    },
    "validation": {
      "type": "inline",
      "checkNullOrWhiteSpace": true,
      "checkDuplicates": true,
      "useFluentValidation": false
    },
    "unitOfWork": {
      "type": "explicit",
      "pattern": "using var uow = _unitOfWorkManager.Begin(requiresNew: true);",
      "savePattern": "await uow.SaveChangesAsync(); await uow.CompleteAsync();"
    },
    "authorization": {
      "permissionPrefix": "BookStorePermissions",
      "classLevel": true,
      "methodLevel": true
    },
    "folderStructure": {
      "contracts": "{RootNamespace}.Application.Contracts/{EntityPlural}/",
      "dtos": "{RootNamespace}.Application.Contracts/{EntityPlural}/Dtos/",
      "application": "{RootNamespace}.Application/{EntityPlural}/"
    },
    "dtoPattern": {
      "location": "separate_folder",
      "naming": "{Entity}Dto.cs"
    },
    "logging": {
      "injected": true,
      "loggerType": "ILogger<T>",
      "infoPattern": "_logger.LogInformation(\"message\", args)",
      "errorPattern": "_logger.LogError(ex, \"message\", args)"
    },
    "mapping": {
      "useObjectMapper": true
    }
  }
}

Store this in memory for use in code generation.

Step 5 — Parse API Specification

For Markdown

# Extract all endpoints
grep -E "^## (GET|POST|PUT|DELETE|PATCH)" api-spec.md

# For each endpoint, extract:
# - HTTP method
# - Path
# - Request body (JSON block after ### Request)
# - Response body (JSON block after ### Response)

Example parsing:

## POST /api/customers
Create a new customer

### Request
```json
{
  "name": "string",
  "email": "string"
}

Response

{
  "id": "guid",
  "name": "string",
  "email": "string"
}


**Extracted:**
- Method: POST
- Path: /api/customers
- Entity: Customer (from path)
- Operation: Create (from POST)
- RequestDto properties: name (string), email (string)
- ResponseDto properties: id (guid), name, email

### For Swagger/OpenAPI

```bash
# Use jq to parse
jq '.paths | keys[]' swagger.json
jq '.paths["/api/customers"].post' swagger.json
jq '.components.schemas.CreateCustomerDto' swagger.json

Step 6 — Generate DTOs Using Detected Pattern

Use the pattern configuration to generate DTOs:

// If pattern.dtoPattern.location == "separate_folder"
create_file(
  path: "{pattern.folderStructure.dtos}/CustomerDto.cs",
  file_text: "using System;
using System.ComponentModel.DataAnnotations;

namespace {pattern.contractsNamespace}.Customers.Dtos
{
    public class CreateCustomerDto
    {
        [Required]
        [StringLength(100)]
        public string Name { get; set; }

        [Required]
        [EmailAddress]
        public string Email { get; set; }
    }

    public class CustomerDto
    {
        public Guid Id { get; set; }
        public string Name { get; set; }
        public string Email { get; set; }
        public DateTime CreationTime { get; set; }
    }

    public class UpdateCustomerDto
    {
        [Required]
        [StringLength(100)]
        public string Name { get; set; }

        [EmailAddress]
        public string Email { get; set; }
    }
}",
  description: "Generated CustomerDto following project conventions"
)

// If pattern.dtoPattern.location == "single_file"
// Generate CustomerDtos.cs with all DTOs in one file

Step 7 — Generate Interface Using Detected Pattern

create_file(
  path: "{pattern.folderStructure.contracts}/ICustomerAppService.cs",
  file_text: "using System;
using System.Threading.Tasks;
using Volo.Abp.Application.Services;
using {pattern.contractsNamespace}.Customers.Dtos;

namespace {pattern.contractsNamespace}.Customers
{
    public interface ICustomerAppService : IApplicationService
    {
        // If pattern.response.type == "wrapped"
        Task<{pattern.response.wrapperType.replace('T', 'CustomerDto')}> CreateAsync(CreateCustomerDto input);
        Task<{pattern.response.wrapperType.replace('T', 'CustomerDto')}> GetAsync(Guid id);
        
        // If pattern.response.type == "plain"
        // Task<CustomerDto> CreateAsync(CreateCustomerDto input);
    }
}",
  description: "Generated ICustomerAppService following project conventions"
)

Step 8 — Generate Implementation Using ALL Detected Patterns

This is the most complex part. Generate code that matches every detected pattern:

// Build the file content dynamically based on patterns
file_content = f"""
using Microsoft.Extensions.Logging;
using System;
using System.Threading.Tasks;
using Volo.Abp.Application.Services;
using Volo.Abp.Domain.Repositories;
"""

// Add UoW using if pattern.unitOfWork.type == "explicit"
if pattern.unitOfWork.type == "explicit":
    file_content += "using Volo.Abp.Uow;\n"

// Add authorization using if detected
if pattern.authorization:
    file_content += f"using Microsoft.AspNetCore.Authorization;\n"

// Add validation using if FluentValidation detected
if pattern.validation.useFluentValidation:
    file_content += "using FluentValidation;\n"

file_content += f"""
using {pattern.contractsNamespace}.Customers.Dtos;
using {pattern.rootNamespace}.Entities;

namespace {pattern.applicationNamespace}.Customers
{{
    {generate_authorization_attribute(pattern)}
    public class CustomerAppService : ApplicationService, ICustomerAppService
    {{
        private readonly IRepository<Customer, Guid> _customerRepository;
        {generate_logger_field(pattern)}
        {generate_unitofwork_field(pattern)}
        {generate_validator_field(pattern)}

        public CustomerAppService(
            IRepository<Customer, Guid> customerRepository{generate_constructor_params(pattern)})
        {{
            _customerRepository = customerRepository;
            {generate_constructor_assignments(pattern)}
        }}

        {generate_create_method(pattern)}
        {generate_get_method(pattern)}
        {generate_update_method(pattern)}
        {generate_delete_method(pattern)}
    }}
}}
"""

create_file(
  path: f"{pattern.folderStructure.application}/CustomerAppService.cs",
  file_text: file_content,
  description: "Generated CustomerAppService following ALL detected patterns"
)

Helper functions:

def generate_create_method(pattern):
    """Generate CreateAsync method matching detected patterns"""
    
    # Start method signature
    if pattern.response.type == "wrapped":
        signature = f"Task<ResponseDto<CustomerDto>> CreateAsync(CreateCustomerDto input)"
    else:
        signature = f"Task<CustomerDto> CreateAsync(CreateCustomerDto input)"
    
    # Build method body
    method = f"""
        {generate_authorization_attribute_for_method(pattern, 'Create')}
        public async {signature}
        {{
    """
    
    # Add try-catch if pattern uses it
    if pattern.errorHandling.tryCatch:
        method += """
            try
            {
        """
    
    # Add logging if pattern uses it
    if pattern.logging.injected:
        method += f"""
                {pattern.logging.infoPattern.format(message="Creating customer: {{Name}}", args="input.Name")};
        """
    
    # Add validation if pattern uses inline validation
    if pattern.validation.type == "inline":
        method += """
                if (string.IsNullOrWhiteSpace(input.Name))
                {
        """
        # Add error response based on pattern
        if pattern.response.type == "wrapped":
            method += f"""
                    return {pattern.response.errorHelper};
        """
        else:
            method += """
                    throw new ArgumentException("Name is required");
        """
        method += """
                }
        """
    
    # Add Unit of Work if pattern uses explicit UoW
    if pattern.unitOfWork.type == "explicit":
        method += f"""
                {pattern.unitOfWork.pattern}
        """
    
    # Entity creation
    method += """
                var customer = new Customer
                {
                    Name = input.Name,
                    Email = input.Email
                };

                await _customerRepository.InsertAsync(customer);
    """
    
    # Complete UoW if used
    if pattern.unitOfWork.type == "explicit":
        method += f"""
                {pattern.unitOfWork.savePattern}
        """
    
    # Logging success
    if pattern.logging.injected:
        method += """
                _logger.LogInformation("Customer created: {Id}", customer.Id);
        """
    
    # Return response
    if pattern.mapping.useObjectMapper:
        method += """
                var dto = ObjectMapper.Map<Customer, CustomerDto>(customer);
        """
    else:
        method += """
                var dto = new CustomerDto
                {
                    Id = customer.Id,
                    Name = customer.Name,
                    Email = customer.Email
                };
        """
    
    if pattern.response.type == "wrapped":
        method += f"""
                return {pattern.response.successHelper.replace('data', 'dto')};
        """
    else:
        method += """
                return dto;
        """
    
    # Close try-catch if used
    if pattern.errorHandling.tryCatch:
        method += """
            }
            catch (Exception ex)
            {
        """
        if pattern.logging.logErrors:
            method += """
                _logger.LogError(ex, "Error creating customer");
        """
        if pattern.response.type == "wrapped":
            method += """
                return this.InternalError<CustomerDto>("An error occurred");
        """
        else:
            method += """
                throw;
        """
        method += """
            }
        """
    
    method += """
        }
    """
    
    return method

This generates code that matches EXACTLY what exists in the project.

Step 9 — Generate AutoMapper Profile (If Detected)

if pattern.mapping.useObjectMapper:
    create_file(
        path: f"{pattern.folderStructure.application}/CustomerApplicationAutoMapperProfile.cs",
        file_text: """..."""
    )

Step 10 — Verify No Conflicts with Existing Files

Before writing ANY file:

# Check if entity already exists
if [ -d "src/Acme.BookStore.Application/Customers" ]; then
    echo "⚠️  Customer service already exists. Skip? (Y/n)"
    # Wait for user confirmation
fi

If user says skip:

Don't create any files for that entity
Report it was skipped
Continue with next entity

Step 11 — Generate API Release Documentation

Generate comprehensive release documentation that can be used for release notes, API documentation, or changelog. The release doc should be generated either from the API specification OR from the generated/gathered interface summaries.

def generate_release_documentation(api_spec, generated_services, pattern_config):
    """
    Generate API release documentation from either:
    1. API Specification (preferred - has full endpoint details)
    2. Generated service interfaces (fallback - summary only)

    Returns a markdown file with complete release information.
    """

    release_doc = f"""
# API Release Documentation

## Overview
- **Project**: {pattern_config['projectName']}
- **Release Date**: {datetime.utcnow().strftime('%Y-%m-%d')}
- **Affected Modules**: {', '.join(extract_entities_from_spec(api_spec))}

---

## New Endpoints

### Summary
Total new endpoints: {count_endpoints(api_spec)}
{generate_endpoint_table(api_spec)}

### Detailed Endpoint Information

{generate_endpoint_details(api_spec)}

---

## Data Transfer Objects (DTOs)

### New DTOs
{generate_dto_summary(generated_services)}

### DTO Field Reference
{generate_dto_field_tables(generated_services)}

---

## Breaking Changes
- None (all new additions, no modifications to existing APIs)

---

## Deprecated Endpoints
{generate_deprecated_section(api_spec)}

**Migration Notes:**
{generate_migration_notes(api_spec)}

---

## Database Schema Changes

### New Tables
{generate_new_tables_section(api_spec)}

### Migration Script
```sql
-- Generated migration script for new entities
{generate_migration_sql(api_spec)}

Permissions Required

New Permission Definitions

{generate_permissions_section(api_spec)}

Add these to your PermissionDefinitionProvider:

public override void SetPermissions(IPermissionDefinitionContext context)
{{
{generate_permission_code(api_spec)}
}}

Integration Checklist

[ ] Add new entity DbSet<T> to your DbContext
[ ] Run new migration: dotnet ef database update
[ ] Add permission definitions to PermissionDefinitionProvider
[ ] Configure AutoMapper profiles (already generated in ProductsApplicationAutoMapperProfile.cs)
[ ] Register services in module (if not auto-registered by ABP)
[ ] Update API version if using versioning
[ ] Test all endpoints with API client (Postman/curl)
[ ] Update API documentation (Swagger/OpenAPI)
[ ] Communicate breaking changes/deprecations to API consumers

Testing Recommendations

Unit Tests

Create tests for each new AppService method
Test validation logic (required fields, unique constraints)
Test error handling scenarios
Test authorization requirements (if applicable)

Integration Tests

Test full request/response cycles
Test database operations
Test pagination and filtering (if applicable)

Rollback Plan

If issues are encountered after deployment:

Disable new endpoints via feature flags (if configured)

Revert database migration (if applied):

-- Drop new tables
{generate_rollback_sql(api_spec)}

Remove permission definitions
Deploy previous version

Support Contacts

Development Team: [team contact]
API Support: [support contact]
Documentation: [link to docs]

Generated by api-spec-to-service skill Generated on: {datetime.utcnow().isoformat()} """

# Write release documentation to file
release_file_path = f"{pattern_config['applicationNamespace'].replace('.', '/')}/../API_RELEASE_{datetime.utcnow().strftime('%Y-%m-%d')}.md"
create_file(
    path=release_file_path,
    file_text=release_doc,
    description="Generated API release documentation"
)

logger.info(f"Release documentation generated: {release_file_path}")


**Key Sections Generated:**

1. **New Endpoints** - Table and details of all endpoints from the spec
2. **DTOs** - All new DTO classes with field descriptions
3. **Breaking Changes** - Any changes that would affect existing API consumers
4. **Deprecated Endpoints** - Endpoints marked as deprecated with migration paths
5. **Database Schema** - New tables and migration SQL
6. **Permissions** - New permission definitions to add
7. **Checklist** - Integration steps for developers
8. **Testing** - Recommended test coverage
9. **Rollback** - SQL to undo changes if needed

**Sources:**
- Parses API spec for endpoint metadata, deprecated flags, DTO definitions
- Analyzes generated DTOs to determine database schema
- Infers database table names from entity names
- Extracts permission requirements (if annotated in spec)
- Uses pattern config for proper naming conventions

---

## Step 12 — Generate Summary with Pattern Report

```markdown
═══════════════════════════════════════════════════════════════════
API Spec → ABP Service Generation Complete
═══════════════════════════════════════════════════════════════════

Project Detected:
  Name: Acme.BookStore
  Contracts Namespace: Acme.BookStore.Application.Contracts
  Application Namespace: Acme.BookStore.Application

Patterns Auto-Detected from BookAppService.cs:
  ✓ Response Pattern: Wrapped with ResponseDto<T>
  ✓ Error Handling: Custom helpers (this.Ok(), this.BadRequest())
  ✓ Validation: Inline validation with null checks
  ✓ Unit of Work: Explicit with IUnitOfWorkManager
  ✓ Authorization: Class + method level with BookStorePermissions prefix
  ✓ Logging: ILogger<T> with structured logging
  ✓ Mapping: ObjectMapper with AutoMapper profiles
  ✓ Folder Structure: Entity-based folders (Books/, Authors/, etc.)

Input Specification:
  File: api-spec.md
  Format: Markdown
  Entities Parsed: 2 (Customer, Order)
  Endpoints: 10

Files Generated (Following Detected Patterns):

Customers/
  ✓ Dtos/CustomerDto.cs
  ✓ Dtos/CreateCustomerDto.cs
  ✓ Dtos/UpdateCustomerDto.cs
  ✓ ICustomerAppService.cs
  ✓ CustomerAppService.cs (matches BookAppService patterns)
  ✓ CustomerApplicationAutoMapperProfile.cs

Orders/
  ✓ Dtos/OrderDto.cs
  ✓ Dtos/CreateOrderDto.cs
  ✓ Dtos/UpdateOrderDto.cs
  ✓ IOrderAppService.cs
  ✓ OrderAppService.cs (matches BookAppService patterns)
  ✓ OrderApplicationAutoMapperProfile.cs

Files Skipped:
  ⚠️  Books/ (already exists, not modified)

Pattern Matching Verification:
  ✓ Response wrappers match existing pattern
  ✓ Error handling matches existing pattern
  ✓ Validation logic matches existing pattern
  ✓ UoW usage matches existing pattern
  ✓ Authorization attributes match existing pattern
  ✓ Logging style matches existing pattern
  ✓ Namespace conventions match existing pattern
  ✓ Folder structure matches existing pattern

Next Steps:
  1. Create domain entities (Customer, Order)
  2. Add permissions to PermissionDefinitionProvider
  3. Build: dotnet build src/Acme.BookStore.Application
  4. Test generated services

═══════════════════════════════════════════════════════════════════

Step 13 — Adaptation Examples

Example 1: Plain DTO Pattern Project

Detected from existing code:

public async Task<BookDto> CreateAsync(CreateBookDto input)
{
    var book = ObjectMapper.Map<CreateBookDto, Book>(input);
    await _bookRepository.InsertAsync(book);
    return ObjectMapper.Map<Book, BookDto>(book);
}

Generated code will match:

public async Task<CustomerDto> CreateAsync(CreateCustomerDto input)
{
    var customer = ObjectMapper.Map<CreateCustomerDto, Customer>(input);
    await _customerRepository.InsertAsync(customer);
    return ObjectMapper.Map<Customer, CustomerDto>(customer);
}

Example 2: Exception-Based Error Handling

Detected:

if (await _bookRepository.AnyAsync(b => b.Name == input.Name))
{
    throw new UserFriendlyException("A book with this name already exists");
}

Generated will match:

if (await _customerRepository.AnyAsync(c => c.Email == input.Email))
{
    throw new UserFriendlyException("A customer with this email already exists");
}

Example 3: Attribute-Based UoW

Detected:

[UnitOfWork]
public async Task<BookDto> CreateAsync(CreateBookDto input)
{
    // No explicit UoW code
}

Generated will match:

[UnitOfWork]
public async Task<CustomerDto> CreateAsync(CreateCustomerDto input)
{
    // No explicit UoW code
}

Step 14 — Reusability Guarantee

This skill works with:

✅ Any ABP Framework version (8.x, 9.x, etc.) ✅ Any project structure (layered, modular, single-layer) ✅ Any response pattern (plain DTOs, wrapped, IActionResult) ✅ Any error handling style (exceptions, helpers, result objects) ✅ Any validation approach (inline, FluentValidation, DataAnnotations) ✅ Any naming convention (Books, BookModule, BookManagement) ✅ Any folder structure (entity folders, flat, feature folders)

The skill adapts to YOUR conventions by learning from YOUR code.

This is now a truly reusable skill that will work perfectly with any ABP project!

Agent Skills: User provides path

Install this agent skill to your local

Skill Files

Philosophy: Pattern Auto-Detection

Step 1 — Read API Specification

Step 2 — Locate ABP Project and Analyze Structure

2.1 Find Application Layer Projects

2.2 Find Existing AppServices (Pattern Source)

Step 3 — Auto-Detect Patterns from Existing Code

3.1 Detect Response Pattern

3.2 Detect Error Handling Pattern

3.3 Detect Validation Pattern

3.4 Detect Unit of Work Pattern

3.5 Detect Authorization Pattern

3.6 Detect Namespace Pattern

3.7 Detect Folder Structure

3.8 Detect DTO Location Pattern

3.9 Detect Logging Pattern

3.10 Detect ObjectMapper Usage

Step 4 — Build Pattern Configuration Object

Step 5 — Parse API Specification

For Markdown

Response

Step 6 — Generate DTOs Using Detected Pattern

Step 7 — Generate Interface Using Detected Pattern

Step 8 — Generate Implementation Using ALL Detected Patterns

Step 9 — Generate AutoMapper Profile (If Detected)

Step 10 — Verify No Conflicts with Existing Files

Step 11 — Generate API Release Documentation

Permissions Required

New Permission Definitions

Integration Checklist

Testing Recommendations

Unit Tests

Integration Tests

Rollback Plan

Support Contacts

Step 13 — Adaptation Examples

Example 1: Plain DTO Pattern Project

Example 2: Exception-Based Error Handling

Example 3: Attribute-Based UoW

Step 14 — Reusability Guarantee