feature: Add RPC client code generation with sbt 2 plugin

[xerial]

Summary

• Add RPC client code generation that produces type-safe client stubs from Scala 3 service traits
• Generated code delegates to RPCClient runtime (mirrors RPCRouter), which uses Surface.methodsOf[T] + MethodCodec for serialization — same codec infrastructure as the server side
• sbt 2.0.0-RC10 plugin runs codegen in-process (no forked JVM) thanks to Scala 3 metabuild
• Add CodeFormatter (Wadler's "A Prettier Printer") to uni-core as a general text utility

Architecture

Component	Purpose
RPCClient (uni)	Runtime dispatch: Surface + MethodCodec for request/response encoding
ServiceScanner (uni/.jvm)	Reflection-based: classloads compiled traits to extract method signatures
RPCClientGenerator (uni/.jvm)	Doc-tree code generation via CodeFormatter
UniHttpCodegenPlugin (sbt-uni-codegen/)	sbt 2 AutoPlugin with sourceGenerators hook
CodeFormatter (uni-core)	Cross-platform Wadler pretty printer

Generated code shape

object UserServiceClient:
  private val rpc = RPCClient.build(
    Surface.of[UserService], Surface.methodsOf[UserService])

  class SyncClient(client: HttpSyncClient):
    def getUser(id: Long): User =
      rpc.callSync[User](client, "getUser", Seq(id))

Test plan

• 37 unit tests (IR model, config parsing, code generation, service scanning, CodeFormatter)
• Scripted sbt 2 test: compile API trait → scan → generate → compile generated code
• All 1374 existing uni tests still pass

🤖 Generated with Claude Code

[gemini-code-assist]

Code Review

This pull request introduces the uni-http-codegen module, which generates type-safe RPC client code from Scala 3 traits using TASTy inspection. The implementation includes an intermediate representation (IR) for service definitions, a scanner to extract metadata from compiled traits, and generators for both synchronous and asynchronous clients. Review feedback suggests optimizing the generated code by decoding JSON directly from values rather than strings to avoid unnecessary roundtrips, ensuring the file writer correctly returns None when no changes are detected as documented, and cleaning up unused variables in the scanner.

[gemini-code-assist]

Avoid unnecessary serialization-deserialization roundtrips. Instead of converting the response to a string and parsing it, use a method that can directly decode from the JSONValue. Additionally, handle empty responses explicitly to avoid cryptic parsing errors.

      sb.append(s"      Weaver.of[${returnType}].fromJson(resp.contentAsJsonValue.getOrElse(throw new IllegalStateException(\"Empty response body\")))\n")

References

1. Avoid unnecessary serialization-deserialization roundtrips when processing JSON values. If a JSON value is already parsed, use a method that can directly decode from the JSONValue instead of converting it to a string and then parsing it again.

[gemini-code-assist]

Avoid unnecessary serialization-deserialization roundtrips. Use a method that decodes directly from the JSONValue. Also, fail fast with an explicit error if the response body is empty to provide clearer debugging information.

      sb.append(
        s"      client.send(req).map(resp => Weaver.of[${returnType}].fromJson(resp.contentAsJsonValue.getOrElse(throw new IllegalStateException(\"Empty response body\"))))\n"
      )

References

1. Avoid unnecessary serialization-deserialization roundtrips when processing JSON values. If a JSON value is already parsed, use a method that can directly decode from the JSONValue instead of converting it to a string and then parsing it again.

[gemini-code-assist]

The documentation for generateAndWrite and run states that None should be returned if the file is unchanged. However, this implementation always returns Some(file). To align with the documentation and provide a clearer signal to callers, this should return None when the file is unchanged.

      None

[gemini-code-assist]

The isAsync variable is declared but its value is never used. This is considered dead code and can be confusing. It should be removed to improve code clarity.

      val returnType =
        if rawReturnType.fullName == "wvlet.uni.rx.Rx" && rawReturnType.typeArgs.nonEmpty then
          rawReturnType.typeArgs.head
        else
          rawReturnType

[xerial]

/gemini review

[xerial]

/gemini review

[gemini-code-assist]

Code Review

This pull request introduces the uni-http-codegen module, which provides a framework for generating type-safe RPC client code from Scala 3 traits using TASTy inspection. Key components include an IR model, a TASTy-based service scanner, and an RPC client source generator. Feedback highlights the need to use fully qualified names in generated code to prevent scoping issues, the importance of adding success checks for HTTP responses before JSON parsing, and a logic correction in the file-writing utility to correctly signal when files remain unchanged.

[gemini-code-assist]

The render method currently uses shortName, which can lead to compilation errors in the generated code if the types are not in the same package as the generated client and no explicit imports are provided. For a code generator, it is safer to use fully qualified names (fullName) to ensure the generated source is valid regardless of the target package.

  def render: String =
    if typeArgs.isEmpty then
      fullName
    else
      s"${fullName}[${typeArgs.map(_.render).mkString(", ")}]"

[gemini-code-assist]

The generated code directly attempts to parse the response body without checking if the HTTP request was successful (e.g., checking for a 2xx status code). If the server returns an error (4xx/500), resp.contentAsString might contain an error message or HTML, which will cause Weaver.of[T].fromJson to throw an exception. Consider adding a check for resp.isSuccess (or equivalent) in the generated code. Additionally, avoid unnecessary serialization-deserialization roundtrips by decoding directly from the JSON value if the response is already parsed.

References

1. Avoid unnecessary serialization-deserialization roundtrips when processing JSON values. If a JSON value is already parsed, use a method that can directly decode from the JSONValue instead of converting it to a string and then parsing it again.

[gemini-code-assist]

The implementation of writeIfChanged returns Some(file) even when the content is unchanged. This contradicts the method's docstring at line 67, which states it should return None if the file was unchanged. This affects the return value of generateAndWrite and run as well.

      None

[gemini-code-assist]

Code Review

This pull request introduces the uni-http-codegen module, which generates type-safe RPC clients from Scala 3 traits using TASTy inspection. The implementation includes an intermediate representation (IR) for service definitions, a TASTy scanner for metadata extraction, and a source code generator for sync and async clients. Feedback suggests improving the TASTy scanner's reliability by filtering for specific service traits and handling annotation parameters more robustly. Additionally, it is recommended to use fully qualified type names in the generated code to prevent potential compilation errors related to missing imports.

[gemini-code-assist]

The TastyServiceScanner.scan method returns the first trait found in the .tasty file. If a file contains multiple traits, this may result in generating a client for the wrong service. It is recommended to filter the scanned services by the expected config.apiClassName.

    val service = TastyServiceScanner.scanAll(List(tastyFilePath)).find(_.fullName == config.apiClassName).getOrElse(throw IllegalStateException(s"Service ${config.apiClassName} not found in ${tastyFilePath}"))

[gemini-code-assist]

Using shortName in TypeRef.render can lead to compilation errors in the generated code if the types are not in the same package as the generated client and are not imported. Using fullName ensures that the generated code is self-contained and avoids name resolution issues.

  def render: String =
    if typeArgs.isEmpty then
      fullName
    else
      s"${fullName}[${typeArgs.map(_.render).mkString(", ")}]"

[gemini-code-assist]

The pattern matching on Apply to extract @Endpoint arguments is fragile as it assumes a specific argument order and lacks support for NamedArg. This will fail if the annotation is used with named parameters (e.g., @Endpoint(method = ..., path = ...)). Consider using a more robust way to inspect annotation parameters by checking for NamedArg or using the symbol's parameter names.