Defc - Go Code Generator

A Go code generation tool that automatically generates CRUD operations for databases, HTTP client code, and net/rpc client/server wrappers based on predefined schemas. Eliminates repetitive boilerplate code by defining interfaces and automatically generating implementation code.

What This Skill Does

This skill helps you work with the `defc` code generation tool in Go projects. It provides guidance on:

Instructions

When working with defc in a Go project, follow these steps:

1. Understand the Project Context

First, examine the repository structure:

2. Code Generation Operations

For generating code:

**Automatic mode detection:**

```bash

Let defc auto-detect the generation mode

defc generate schema.go

```

**Explicit mode selection:**

```bash

Generate database CRUD operations

defc --mode=sqlx --output=query.go schema.go

Generate HTTP client code

defc --mode=api --output=service.go schema.go

Generate net/rpc wrappers

defc --mode=rpc --output=client.go schema.go

```

**Understanding mode detection:**

3. Testing Generated Code

Run tests in this order:

```bash

1. Run the main test script (preferred)

./test.sh

2. Test specific modules

go test -cover ./gen

go test -cover ./runtime

go test -cover ./sqlx

3. Run integration tests (includes RPC)

go test -tags=test ./gen/integration

4. Test specific functionality

go test -run TestRunCommand ./gen

go test -run TestRpc -tags=test ./gen/integration

```

**Code validation:**

```bash

Always prefer go vet over go build for validation

go vet ./...

go vet ./gen

```

4. Building and Installing

```bash

Build the binary

go build

Install globally

go install

Run directly without installing

go run -mod=mod github.com/x5iu/defc@latest --help

```

5. Interface Definition Patterns

When creating or modifying interface schemas:

**For sqlx mode (database operations):**

**For api mode (HTTP clients):**

**For rpc mode (net/rpc wrappers):**

6. Code Generation Architecture

The generation flow:

1. Parse Go interface definitions using `go/ast` and `go/parser`

2. Extract method signatures and comments with SQL/HTTP specifications

3. Auto-detect generation mode via `DetectTargetDecl` (gen/tools.go:360-407)

4. Build context with `CliBuilder` pattern (imports, features, functions, templates)

5. Apply Go templates (`sqlx.tmpl`, `api.tmpl`, `rpc.tmpl`) to generate code

6. Format with `go/format` and manage imports with `goimports`

7. Write to output file

7. Working with Templates

When modifying generation templates in `gen/template/`:

Generated code follows naming conventions:

8. Feature Flags and Options

The tool supports modular features:

Enable features based on project requirements using the builder pattern.

9. Common Development Tasks

**When adding new generation modes:**

1. Create a template in `gen/template/`

2. Add detection logic in `DetectTargetDecl` (gen/tools.go:360-407)

3. Implement builder methods in `gen/builder.go`

4. Add integration tests in `gen/integration/`

**When debugging generation:**

1. Check AST parsing in relevant gen/ files

2. Verify template syntax in `gen/template/*.tmpl`

3. Run with `--disable-auto-import` to isolate import issues

4. Use `go vet` for validation instead of `go build`

**When writing tests:**

Important Notes

Examples

**Generate database CRUD from interface:**

```bash

defc --mode=sqlx --output=db_generated.go user_schema.go

```

**Generate HTTP client with auto-detection:**

```bash

defc generate api_schema.go

```

**Generate RPC wrappers without runtime:**

```bash

defc --mode=rpc --features=rpc/nort --output=rpc_client.go service.go

```

**Run full test suite:**

```bash

./test.sh

```

Constraints