sed no makefile não está funcionando como esperado ao usar regex

\U, como -r(para o qual -Eagora é o equivalente padrão) é uma extensão não padrão da implementação GNU de sed, inspirada em ex/ vi, também encontrada em perl, não encontrada em muitas outras implementações.

Aqui, em vez disso, você poderia fazer:

SHELL = zsh
test:
        @for f (cmd/*(N:t)) print -rl -- $$f $${$${(C)f}//_}

Usando:

• cmd/*(N:t)para expandir o glob de Nforma ullglob, obtendo o tail de cada expansão.
• ${(C)var}para colocar palavras em maiúscula na variável
• ${var//_}à la ksh para remover _caracteres posteriormente
• print -rl --para imprimir raw em llinhas separadas.

Observe que os nomes dos arquivos são decodificados em texto e convertidos para letras maiúsculas de acordo com a localidade do usuário (categoria LC_CTYPE).

O exemplo acima, para cada sequência de um ou mais caracteres alfanuméricos, converte o primeiro caractere para maiúsculas e todos os demais para minúsculas, além de remover todos os sublinhados.

Uma abordagem mais próxima da sua é remover apenas os sublinhados seguidos por uma letra minúscula (e converter somente essa letra para maiúscula, deixando o resto intacto):

SHELL = zsh
test:
        @set -o extendedglob; for f (cmd/*(N:t)) \
          print -rl -- $$f $${f//(#b)((#s)|_)([[:lower:]])/$$match[2]:u}

Onde

• (#b)é ativar referências posteriores, para que grupos de captura possam ser referenciados na $matchmatriz na substituição
• (#s)para storta, o equivalente a regex^
• [[:lower:]]corresponde a caracteres classificados como minúsculos, como em expressões regulares. [a-z]para restringir àqueles entre ae zque em zshé feito com base no valor do ponto de código, portanto limitado a abcdefghijklmnopqrstuvwxyz
• $var:upara converter para maiúsculas como em csh, respeitando o idioma.

Sem zsh:

test:
        @CDPATH= cd cmd && \
          perl -le 'for (<*>) {print; s/[[:alnum:]]+/\u\L$$&/g; s/_//g; print}'

Assume apenas letras ASCII ( stéphaneseria alterado para, StéPhanepor exemplo, pois énão é reconhecido como uma letra).

Ou como na sua abordagem:

test:
        @CDPATH= cd cmd && \
          perl -le 'for (<*>) {print; s/(^|_)([a-z])/\U$$2/g; print}'

Se limitado a utilitários POSIX, você pode usar awkpara fazer a capitalização:

test:
        @CDPATH= cd cmd && awk -- '                              \
          BEGIN {for (i = 1; i < ARGC; i++) {                    \
            arg = ARGV[i]; out = "";                             \
            print arg;                                           \
            while (match(arg, /[[:alnum:]]+/)) {                 \
              out = out                                          \
                    substr(arg, 1, RSTART - 1)                   \
                    toupper(substr(arg, RSTART, 1))              \
                    tolower(substr(arg, RSTART+1, RLENGTH - 1)); \
              arg = substr(arg, RSTART+RLENGTH)};                \
              out = out arg;                                     \
              gsub("_", "", out);                                \
              print out                                          \
            }                                                    \
          }' *

Assim como o zsh, ele respeitará o idioma para decodificar nomes de arquivos como texto, classificando caracteres alnume convertendo-os para letras maiúsculas.

Para combinar com sua abordagem:

test:
        @CDPATH= cd cmd && awk -- '                                   \
          BEGIN {for (i = 1; i < ARGC; i++) {                         \
            arg = ARGV[i]; out = ""; x = 0;                           \
            print arg;                                                \
            while (match(arg, (x++ ? "_" : "(^|_)") "[[:lower:]]")) { \
              out = out                                               \
                    substr(arg, 1, RSTART-1)                          \
                    toupper(substr(arg, RSTART+RLENGTH-1, 1));        \
              arg = substr(arg, RSTART+RLENGTH)};                     \
              out = out arg;                                          \
              gsub("_", "", out);                                     \
              print out                                               \
            }                                                         \
          }' *

Algumas outras notas:

• Seu $(shell ...)é expandido por makepara o código que foi passado sem qualquer tipo de sanitização, portanto, não funcionará para nomes de arquivo que contenham caracteres especiais na sintaxe do shell, como espaço, ;, *, 'etc. Na verdade, esse é um caso típico de vulnerabilidade de execução arbitrária de código. Mas, por outro lado, ao usar, makevocê precisa desistir e esperar fazer qualquer coisa com segurança ou confiabilidade. Ele só deve ser usado com dados estritamente controlados (aqui pode ser adequado se você puder garantir que o cmddiretório conterá apenas os arquivos que você espera).
• echonão pode ser usado para dados arbitrários
• em shells diferentes de zsh, incluindo sho shell padrão para make, expansões de parâmetros devem ser colocadas entre aspas para evitar split+glob, então $${f}deve ser assim "$$f"(ou "$${f}"se preferir).

Seu comentário nos diz que:

1. Você não está usando o GNU sed, que é necessário para \U.
2. Seu problema não tem nada a ver com chamar sed de um Makefile, já que você obtém o mesmo comportamento apenas chamando sed diretamente na linha de comando.

Em vez de depender do GNU sed, você pode fazer isso usando qualquer awk em qualquer shell em qualquer máquina Unix:

$ echo 'api_get_manual' |
awk '{
    r = "_" $0
    while ( match(r, /_[a-z]/) ) {
        r = substr(r,1,RSTART-1) toupper(substr(r,RSTART+1,1)) substr(r,RSTART+RLENGTH)
    }
    sub(/^_/, "", r)
    print r
}'
Api_Get_Manual

Aqui está o exemplo acima sendo executado em alguma entrada que não é abordada no exemplo da pergunta, para que você possa decidir se a saída é desejável ou não:

$ cat file
api_get_manual
this_7
_That
foo:bar
foo.pdf
bar.c

awk '{
    r = "_" $0
    while ( match(r, /_[a-z]/) ) {
        r = substr(r,1,RSTART-1) toupper(substr(r,RSTART+1,1)) substr(r,RSTART+RLENGTH)
    }
    sub(/^_/, "", r)
    print $0 "\t-> " r
}' file
api_get_manual  -> ApiGetManual
this_7  -> This_7
_That   -> _That
foo:bar -> Foo:bar
foo.pdf -> Foo.pdf
bar.c   -> Bar.c

Para usar qualquer um dos itens acima em um Makefile $0é preciso tornar-se $$0e o script awk tem que logicamente estar todos em uma linha, então você precisa adicionar alguns ;s e escapar as novas linhas dentro do script, por exemplo (não testado):

awk '{                                      \
    r = "_" $$0;                            \
    while ( match(r, /_[a-z]/) ) {          \
        r = substr(r,1,RSTART-1) toupper(substr(r,RSTART+1,1)) substr(r,RSTART+RLENGTH) \
    }                                       \
    sub(/^_/, "", r);                       \
    print r                                 \
}'