download auto rust - download do código-fonte auto rust

auto rust

Outro código-fonte

1.0.0

Baixar

Ferrugem Automática

auto-rust é uma macro processual Rust que aproveita o poder dos Large Language Models (LLMs) para gerar código em tempo de compilação. Escreva uma assinatura de função, adicione um comentário ao documento descrevendo a funcionalidade desejada e deixe auto-rust preencher os detalhes da implementação!

️ Aviso

O Auto-Rust está atualmente em desenvolvimento e ainda não é adequado para uso em produção. Embora você possa experimentá-lo e fornecer feedback, alertamos que ele pode ter uma implementação incompleta e não funcionar conforme o esperado.

Características

Geração de código com tecnologia de IA: Aproveite os recursos dos LLMs para gerar corpos de funções Rust com base em suas especificações.
Integração em tempo de compilação: integre perfeitamente a geração de código em seus projetos Rust com nossa macro processual fácil de usar.
Geração baseada no contexto: o Auto-Rust considera a assinatura da sua função, comentários do documento e algum código dentro do seu projeto para gerar implementações contextualmente relevantes.
Cache integrado: o Auto-Rust armazena em cache os resultados bem-sucedidos da geração de código para acelerar seu fluxo de trabalho de desenvolvimento. Evite chamadas LLM desnecessárias e reduza os tempos de compilação!

Começando

1. Instalação

Adicione auto-rust como uma dependência em seu arquivo Cargo.toml :

[ dependencies ]
auto-rust = " 0.1.4 "

2. Chave API

Auto-Rust requer uma chave de API OpenAI. Crie um arquivo .env na raiz do seu projeto e adicione sua chave:

OPENAI_API_KEY= < your-openai-api-key >

3. Uso

Anote sua função com o atributo #[llm_tool] e forneça um comentário claro no documento explicando o comportamento desejado:

 use auto_rust :: llm_tool ;

# [ llm_tool ]
# [ handler ]
/// The response will be an HTML layout with the name and the number of letters in the name.
/// Ensure to return a content type of text/html.
fn hello ( Path ( name ) : Path < String > ) -> impl IntoResponse {
    todo ! ( )
}

Recarga ao vivo com argumento live

Para habilitar o recarregamento ao vivo para um desenvolvimento contínuo, use o argumento live para a macro llm_tool .

 # [ llm_tool ( live ) ]

Habilitar o recarregamento live força o Auto-Rust a ignorar seu mecanismo de cache. Em cada compilação, ele enviará uma solicitação ao LLM, garantindo que você sempre receba a geração de código mais atualizada com base na assinatura da função, nos comentários do documento e no contexto atual da base de código.

Como funciona o cache

Auto-Rust implementa um mecanismo de cache simples. Cada vez que gera código para uma função:

Ele cria um hash com base na assinatura da função, nos comentários do documento e no contexto do código relevante.
Este hash é usado para armazenar o código gerado pelo LLM.
Nas compilações subsequentes, o Auto-Rust verificará primeiro se existe um resultado em cache para o hash fornecido. Se encontrado, ele usa diretamente o código em cache, evitando chamadas LLM desnecessárias.

Use o argumento live quando quiser priorizar o recebimento da geração de código mais atual do LLM, mesmo que isso leve a tempos de compilação ligeiramente maiores.

Exemplo

 use auto_rust :: llm_tool ;
use poem :: {
    get , handler , listener :: TcpListener , middleware :: Tracing , web :: Path , EndpointExt , IntoResponse ,
    Route , Server ,
} ;

# [ llm_tool ]
# [ handler ]
/// The response will be an html layout with the name and the number of letters in the name.
/// Ensure to return a content type of text/html.
fn hello ( Path ( name ) : Path < String > ) -> impl IntoResponse {
    todo ! ( )
}

# [ tokio :: main ]
async fn main ( ) -> Result < ( ) , std :: io :: Error > {
    // ...
}

Código gerado:

 # [ handler ]
/// The response will be an html layout with the name and the number of letters in the name.
/// Ensure to return a content type of text/html.
fn hello ( Path ( name ) : Path < String > ) -> impl IntoResponse {
    let response_html = format ! (
    r#"
<!DOCTYPE html>
<html>
<head>
    <title>Hello, {name}!</title>
</head>
<body>
    <h1>Hello, {name}!</h1>
    <p>The length of your name is {len} letters.</p>
</body>
</html>
"# ,
    name = name,
    len = name.len ( )
) ;

poem :: Response :: builder ( )
    . header ( "Content-Type" , "text/html; charset=utf-8" )
    . body ( response_html )
}

Explicação para desenvolvedores

Auto-Rust utiliza o poderoso sistema de macro processual do Rust para injetar código em tempo de compilação. Ao usar a macro #[llm_tool] :

Análise: A macro analisa a assinatura da função anotada, incluindo seu nome, argumentos, tipo de retorno e quaisquer comentários do documento.
Extração de Contexto: Extrai o código dentro do seu projeto, fornecendo algum contexto para o LLM entender melhor o código circundante e o projeto.
Engenharia de Prompt: Constrói um prompt que inclui as informações extraídas. Este prompt foi cuidadosamente projetado para orientar o LLM na geração de uma implementação de função Rust relevante e correta.
Interação LLM: Envia o prompt gerado para uma API LLM.
Inserção de código: a resposta do LLM, que contém o código Rust gerado, é inserida diretamente em sua base de código, substituindo o espaço reservado todo!() .

Limitações

Não-determinismo do LLM: a saída do LLM pode variar. Talvez seja necessário experimentar e iterar para alcançar os resultados desejados.
Contexto limitado: atualmente, o contexto do Auto-Rust é baseado principalmente na assinatura da sua função e nos comentários do documento. Tem conhecimento limitado da estrutura mais ampla do projecto.
Gerenciamento de dependências: o Auto-Rust não adiciona automaticamente instruções use para dependências recém-introduzidas no código gerado.

Contribuindo

Aceitamos contribuições da comunidade Rust! Se você encontrar problemas, tiver sugestões ou quiser contribuir para o desenvolvimento do auto-rust , sinta-se à vontade para abrir um problema ou enviar uma solicitação pull.