feat: add Go plugin support for custom lint rules

[julioz]

Add Go Plugin Support for Custom Lint Rules

This PR implements support for custom lint rules via Go plugins, addressing the need discussed in issue #1485.

Background

Organizations adopting AIPs often need to extend the api-linter with custom rules specific to their requirements. Previously, this required forking the repository and maintaining a custom version, which introduces operational overhead.

Implementation

This PR adds a --rule-plugin flag to the api-linter CLI, allowing users to load custom rules from Go plugin (.so) files at runtime. The implementation:

1. Uses Go's native plugin package to dynamically load custom rules
2. Defines a simple plugin API: plugins must export an AddRules function with the signature:

   func AddRules(r lint.RuleRegistry) error

3. Provides sample code and build scripts for plugin authors

This approach follows the "simple implementation" described in issue comment #1485, focusing on a straightforward solution that can be implemented quickly with minimal changes.

Reviewing the Changes

I recommend reviewing this PR commit by commit to understand the focused nature of each changeset:

1. First commit introduces the core plugin loading functionality
2. Second commit adds the build-all.sh script for compatible builds
3. Third commit improves the plugin build script with version detection
4. Final commit adds the test proto file for demonstration

Each commit solves a specific problem related to the plugin system implementation.

Challenges & Solutions

Go's plugin system has strict version compatibility requirements - plugins must be built with:

• The exact same Go version as the api-linter binary
• The exact same dependency versions

To address this, we provide:

1. A build-all.sh script that builds both the api-linter and its plugin in the same environment
2. A julioz-api-rules/build.sh script with version detection to ensure compatibility

Testing

To run the tests for the plugin functionality:

# Run all tests in the cmd/api-linter package
go test ./cmd/api-linter/...

# Run specifically the plugin loading tests
go test ./cmd/api-linter -run TestLoadCustomRulePlugins

The build-all.sh script also includes a test phase that validates the plugin works with a sample proto file:

./build-all.sh

Usage Example

Building

# Build both api-linter and the plugin
./build-all.sh

# Output:
# Building with go version go1.23.3 darwin/arm64
# Building api-linter...
# ...
# Built plugin with:
# julioz-api-rules.so: go1.23.3
# ...
# ✓ Plugin test successful

Sample Plugin

The PR includes a sample plugin with a custom rule requiring message names to start with "Julio":

// This message should fail our rule since it doesn't start with "Julio"
message TestMessage {
  // The name of the test message
  string name = 1;
}

// This message should pass our rule
message JulioTestMessage {
  // The ID of the test message
  int32 id = 1;
}

Running the Linter

./api-linter-with-plugins --rule-plugin=julioz-api-rules/julioz-api-rules.so --proto-path=. julioz-api-rules/test.proto

Output

- file_path: julioz-api-rules/test.proto
  problems:
    - message: Message names must start with 'Julio'
      suggestion: JulioTestMessage
      location:
        start_position:
            line_number: 13
            column_number: 1
        end_position:
            line_number: 16
            column_number: 1
        path: julioz-api-rules/test.proto
      rule_id: internal::9001::julio-prefix
      rule_doc_uri: ""

Future Considerations

Given the plans for a major version bump in the near future, there are opportunities to improve the plugin system:

1. Replacing this implementation with an RPC-based plugin system like hashicorp/go-plugin, which would be more resilient to Go version incompatibilities
2. Publishing guidelines for plugin authors and providing better documentation