# Find all route registration code
grep -r "app\.\(Get\|Post\|Put\|Delete\)" . --include="*.go"

# Find all Wire provider functions
grep -r "wire\.NewSet\|wire\.Build" . --include="*.go"

# Count your handlers
find . -name "*handler*.go" -o -name "*controller*.go" | wc -l

Document your findings:

How many handlers do you have?
Where is route registration currently done?
Where are Wire providers currently defined?

Install and configure Taskw

Add Taskw to your project:

# Install Taskw
go install github.com/nkaewam/taskw@latest

# Initialize in your project root
taskw init

Edit the generated taskw.yaml to match your project structure:

version: "1.0"
project:
  module: "github.com/yourcompany/your-existing-project"
paths:
  scan_dirs: 
    - "./internal/handlers"  # Your handler directories
    - "./internal/api"
    - "./pkg/controllers"
  output_dir: "./internal/api"  # Where to generate files
generation:
  routes:
    enabled: true
    output_file: "routes_gen.go"
  dependencies:
    enabled: true
    output_file: "dependencies_gen.go"

Add annotations to existing handlers

Transform your existing handler methods by adding @Router annotations:

Before:

func (h *UserHandler) GetUsers(c *fiber.Ctx) error {
    // Your existing logic
    return c.JSON(users)
}

After:

// GetUsers retrieves all users
// @Summary Get all users
// @Description Get a list of all users in the system
// @Tags users
// @Accept json
// @Produce json
// @Success 200 {array} User
// @Router /api/v1/users [get]
func (h *UserHandler) GetUsers(c *fiber.Ctx) error {
    // Your existing logic (unchanged)
    return c.JSON(users)
}

Pro tip: Start with one handler package and test the generation before annotating everything.

Add provider functions

If you don't already have provider functions, add them:

Before:

// Constructor function
func NewUserHandler(service *UserService) *UserHandler {
    return &UserHandler{service: service}
}

After:

// ProvideUserHandler creates a new user handler (Wire provider)
func ProvideUserHandler(service *UserService) *UserHandler {
    return &UserHandler{service: service}
}

// Keep the old constructor for backward compatibility (optional)
func NewUserHandler(service *UserService) *UserHandler {
    return ProvideUserHandler(service)
}

Generate code and test

Generate the Taskw code:

taskw generate
go mod tidy
go generate ./...

This creates:

internal/api/routes_gen.go - Generated route registration
internal/api/dependencies_gen.go - Generated Wire providers

Update your main server file

Replace manual route registration with generated code:

Before:

// cmd/server/main.go (or wherever you register routes)
func main() {
    app := fiber.New()
    
    // Manual route registration
    userHandler := &handlers.UserHandler{...}
    app.Get("/api/v1/users", userHandler.GetUsers)
    app.Post("/api/v1/users", userHandler.CreateUser)
    // ... 50 more routes
    
    app.Listen(":8080")
}

After:

// cmd/server/main.go
func main() {
    app := fiber.New()
    
    // Wire-generated server with all dependencies
    server, cleanup, err := api.InitializeServer()
    if err != nil {
        log.Fatal("Failed to initialize server:", err)
    }
    defer cleanup()
    
    // Taskw-generated route registration  
    if err := server.RegisterRoutes(app); err != nil {
        log.Fatal("Failed to register routes:", err)
    }
    
    app.Listen(":8080")
}

Update Wire configuration

Update your Wire setup to use generated providers:

Before:

// internal/api/wire.go
var ProviderSet = wire.NewSet(
    // Manual provider list
    handlers.NewUserHandler,
    services.NewUserService,
    repositories.NewUserRepository,
    // ... 50 more providers
)

After:

// internal/api/wire.go
var ProviderSet = wire.NewSet(
    // Manual providers (keep existing ones you need)
    provideLogger,
    provideFiberApp,
    provideDatabase,
    
    // Generated providers from Taskw
    GeneratedProviderSet,
    
    // Server constructor
    NewServer,
)

Test your migration

Verify everything works:

# Build your project
go build -o bin/server cmd/server/main.go

# Run your server
./bin/server

# Test endpoints
curl http://localhost:8080/api/v1/users
curl http://localhost:8080/health

Clean up old code (optional)

Once everything is working, you can remove:

Manual route registration code
Manual Wire provider lists (keep manual providers for non-generated dependencies)
Unused constructor functions (if you converted them all to providers)

Common Migration Scenarios

Scenario 1: Existing Wire Setup

Current setup:

// You already have Wire working
var ProviderSet = wire.NewSet(
    NewUserHandler,
    NewUserService,
    NewUserRepository,
)

Migration:

Rename NewUserHandler to ProvideUserHandler
Add @Router annotations to handler methods
Run taskw generate
Replace manual provider list with GeneratedProviderSet

Scenario 2: Manual Route Registration

Current setup:

// You register routes manually
func SetupRoutes(app *fiber.App) {
    api := app.Group("/api/v1")
    api.Get("/users", userHandler.GetUsers)
    // ...
}

Migration:

Add @Router annotations with full paths: /api/v1/users [get]
Add provider functions for handlers
Run taskw generate
Replace SetupRoutes() with server.RegisterRoutes(app)

Scenario 3: No Dependency Injection

Current setup:

// You manually create handler dependencies
userRepo := &UserRepository{db: db}
userService := &UserService{repo: userRepo}
userHandler := &UserHandler{service: userService}