Repositório: https://github.com/regyssilveira/RadIA-Plugin
Em poucas versões, o RadIA evoluiu de um assistente integrado ao editor para uma plataforma agêntica com 124 ferramentas, capaz de participar de jornadas completas de criação, build, testes, depuração, diagnóstico de memória e validação de correções.
Quem desenvolve em Delphi sabe que escrever código é apenas uma parte do trabalho. O ciclo real inclui compreender projetos antigos, localizar units, interpretar mensagens do compilador, criar e executar testes, reproduzir erros que só aparecem em runtime, analisar a pilha de chamadas e, nos casos mais difíceis, perseguir vazamentos de memória.
Foi olhando para essa jornada completa que o RadIA evoluiu.
Na versão 1.0.0, ele já era muito mais do que uma janela de chat. O plugin se integrava ao editor do Delphi, entendia o contexto da unit ativa, trabalhava com vários provedores de IA, criava e revisava código, preparava alterações seguras e acessava recursos da IDE por ferramentas estruturadas.
Agora, na versão 2.2.1, o RadIA chega a outro estágio: ele não apenas sugere o que o desenvolvedor poderia fazer. Com autorização, limites claros e etapas revisáveis, ele consegue participar da execução do trabalho dentro da própria IDE.
O salto iniciado na versão 1.0.0
A versão 1.0.0 estabeleceu a base de uma plataforma agêntica segura para Delphi. Além do chat acoplado à IDE, já havia integração com o editor, Smart Diff, build, Form Designer, debugger, conhecimento local do projeto e uma bridge MCP para clientes externos.
Essa base era importante porque eliminava um dos maiores limites de um chat convencional: receber uma resposta correta, mas precisar transportar manualmente cada sugestão para o ambiente de desenvolvimento.
No RadIA, a IA podia trabalhar com o contexto real e preparar ações concretas. As alterações de código já seguiam um fluxo revisável, com preview, verificação do conteúdo original e possibilidade de reversão. Operações com impacto passavam por consentimento e permaneciam confinadas ao workspace autorizado.
Em outras palavras, a 1.0.0 criou os fundamentos: contexto, ferramentas, segurança e integração com a Open Tools API do Delphi.
RadIA 2.0: a jornada completa de desenvolvimento
A versão 2.0 transformou ferramentas isoladas em jornadas ponta a ponta. Em vez de pedir uma ação por vez, o desenvolvedor passou a poder declarar um objetivo: criar uma aplicação, corrigir um build, escrever testes, depurar uma falha, modernizar código legado, migrar uma tecnologia ou preparar uma release.
Essas jornadas seguem quatro ideias simples:
- o agente apresenta um plano antes de alterar qualquer coisa;
- cada operação respeita risco, consentimento e limites do workspace;
- o trabalho produz evidências, como diff, resultado de build, testes e estado do debugger;
- sucesso não é apenas uma mensagem otimista: é a conclusão dos critérios definidos para a jornada.
Na prática, uma jornada de correção de build pode ler as mensagens reais do compilador, localizar o código relacionado, preparar a menor alteração possível, mostrar o diff, aplicar a correção aprovada e compilar novamente.
Uma jornada de testes pode identificar uma lacuna, criar testes DUnitX, adicionar os arquivos ao projeto, executar a suíte e usar o resultado como gate. Se houver falha, o agente recebe evidência estruturada, incluindo status, duração, mensagens e stack traces, e pode preparar uma nova correção.
A versão 2.0 também consolidou recursos como terminal integrado, Ghost Text multilinha, revisão inline, criação de projetos e forms, conhecimento local indexável, operações no Form Designer, commits Git locais revisáveis e extensões declarativas.
Foi o momento em que o RadIA deixou de ser apenas um conjunto de atalhos inteligentes e passou a orquestrar ciclos completos de desenvolvimento.
RadIA 2.1: reproduzir, corrigir e provar uma falha em runtime
Alguns bugs não aparecem no compilador nem em uma análise estática. Eles surgem quando o usuário abre uma tela, clica em um botão, confirma uma operação ou fecha um formulário em uma sequência específica.
A versão 2.1 atacou exatamente esse problema com o diagnóstico autônomo de runtime.
O RadIA passou a poder compilar o projeto, iniciar uma nova sessão pelo debugger da IDE, identificar com segurança o processo depurado, descobrir suas janelas e controles e executar um cenário visual limitado. Durante a reprodução, ele pode correlacionar exceções, call stack, eventos do debugger e evidências do processo.
Depois de preparar uma correção revisável, o mesmo cenário pode ser repetido em outra build. Assim, o resultado deixa de ser “parece que corrigiu” e passa a ser uma comparação entre a execução que falhou e a execução que validou a mudança.
O cenário também pode ser salvo em .radia/runtime-scenarios e executado novamente como regressão. Isso é especialmente útil para falhas visuais difíceis de descrever e fáceis de reintroduzir.
O ponto central é que essa automação não controla processos arbitrários nem aceita coordenadas globais sem contexto. Ela opera sobre o processo depurado e seus descendentes, com limites, fingerprints, preview e consentimento.
RadIA 2.2: diagnóstico de vazamentos de memória com FastMM5
Vazamentos de memória costumam exigir uma sequência trabalhosa: configurar o gerenciador de memória, instrumentar o projeto, reproduzir o comportamento, encerrar corretamente a aplicação, localizar o log, separar frames do projeto de frames da RTL e da VCL, encontrar a origem provável da alocação e repetir tudo depois da correção.
Na versão 2.2, o RadIA passou a compor esse fluxo em uma sessão reversível de diagnóstico com FastMM5.
Com o FastMM5 fornecido e configurado pelo usuário, o RadIA pode:
- verificar se o ambiente está pronto para o diagnóstico;
- preparar uma instrumentação temporária e revisável no DPR;
- compilar o projeto em Debug;
- iniciar a aplicação como processo supervisionado;
- executar aquecimento e repetições controladas de um cenário;
- capturar snapshots antes e depois da medição;
- interpretar o relatório do FastMM5;
- agrupar leaks e apresentar stacks, linhas, fingerprints e números de alocação;
- sugerir o primeiro frame relevante pertencente ao projeto;
- preparar uma correção e repetir o mesmo cenário;
- comparar as evidências e classificar o resultado como corrigido, melhorado, inalterado ou regredido;
- restaurar o DPR original mesmo quando alguma etapa falha ou é cancelada.
Essa última parte é essencial. O diagnóstico não pode deixar o projeto permanentemente alterado só porque houve timeout, cancelamento ou erro no processo. Por isso, a instrumentação é tratada como uma operação reversível e possui mecanismos de recuperação.
O RadIA não substitui o FastMM5 e não promete encontrar sozinho todo tipo de consumo de recurso. Handles, GDI, COM e GPU exigem evidências próprias. Para heap e leaks identificados pelo FastMM5, porém, ele reduz significativamente o trabalho mecânico entre reproduzir, localizar, corrigir e comprovar.
RadIA 2.2.1: menos atrito para começar e entender o ambiente
A versão 2.2.1 fecha várias lacunas de experiência. Quanto mais capaz se torna uma plataforma, mais importante é explicar com clareza o que está configurado, o que está disponível e qual é o próximo passo.
O comando /doctor agora executa um diagnóstico estruturado da instalação. Ele verifica provider, executor, terminal, MCP quando necessário, recursos web e disponibilidade das ferramentas básicas. O relatório apresenta score, checks, recomendações e a próxima ação, sem expor credenciais.
O novo /status oferece um inventário sanitizado e filtrável. É possível consultar a visão geral ou focar em provider, agente, CLI, MCP, segurança, editor, projeto, ferramentas e logging.
A configuração de CLI e MCP também ganhou uma experiência guiada: o RadIA detecta o estado atual, explica o que falta, solicita consentimento quando uma ação é necessária, valida o resultado e oferece um caminho manual quando a automação não for possível. Tudo isso sem exigir que o usuário descubra detalhes internos do plugin ou reinicie a IDE a cada tentativa.
A 2.2.1 ainda traz correções de estabilidade no debugger, melhorias na seleção dinâmica de modelos, ajustes de interface e uma documentação reorganizada por tarefa.
O que representam 124 ferramentas dentro do Delphi
O catálogo atual do RadIA possui 124 ferramentas internas. O número chama atenção, mas o mais importante é como elas se combinam.
Há ferramentas para consultar o estado da IDE, projeto, units, arquivos abertos, seleção do editor, posição do cursor, símbolos e mensagens do compilador. Outras preparam, aplicam e revertem patches em um ou vários arquivos, modificam a estrutura do projeto e executam transações de desenvolvimento.
O catálogo inclui build, DUnitX, cobertura, navegação, Form Designer, debugger, breakpoints, watches, call stack, timeline, conhecimento local, terminal, Git, automação de runtime e diagnóstico FastMM5. O RadIA também pode criar projetos a partir de templates, adicionar e remover componentes, alterar propriedades e eventos, publicar revisões inline e produzir evidências comparáveis.
Essas ferramentas são compartilhadas pelo modo agente e pela integração MCP. Isso permite usar a experiência nativa dentro do Delphi ou conectar um cliente local autorizado ao mesmo conjunto de capacidades e políticas.
O chat também continua flexível em relação aos modelos. O RadIA suporta provedores comerciais e locais, incluindo OpenAI, Gemini, Claude, Azure OpenAI, AWS Bedrock, GitHub Copilot, DeepSeek, Groq, Qwen, Mistral, OpenRouter, Ollama e LM Studio, além de endpoints compatíveis com a API da OpenAI.
O que ele pode fazer sozinho — e o que continua sob seu controle
“Autônomo” não significa acesso irrestrito.
O RadIA consegue encadear ferramentas, executar etapas de um plano, observar resultados e decidir o próximo passo. Ele pode, por exemplo, compilar, interpretar um erro, preparar uma alteração, recompilar e executar testes. Também pode reproduzir um bug, capturar evidências, aplicar uma correção autorizada e repetir o cenário.
Mas as ações sensíveis continuam protegidas por consentimento, revisão e limites. Patches possuem preview e precondições. Caminhos ficam restritos ao workspace. Credenciais são protegidas localmente com Windows DPAPI. Logs e diagnósticos são sanitizados. O usuário pode pausar, retomar ou cancelar a execução e revisar o plano antes da primeira mutação.
Essa combinação é, para mim, a parte mais importante da evolução: autonomia suficiente para remover trabalho repetitivo, sem retirar do desenvolvedor a responsabilidade e o controle sobre o projeto.
Uma plataforma construída para quem vive Delphi
O RadIA é escrito em Object Pascal e integrado ao Delphi pela Open Tools API. Ele conhece detalhes que fazem diferença nesse ecossistema: units, DPR, DFM, project groups, Form Designer, mensagens do compilador, DUnitX, debugger e as particularidades de Win32 e IDE64.
A matriz atual suporta e valida Delphi 12 Win32, Delphi 13 Win32 e Delphi 13 IDE64. A qualidade da própria release também é tratada como produto: a versão 2.2 foi validada com mais de 800 testes por target, zero falhas e zero leaks na suíte, além de gates de documentação, frontend e SonarQube.
Ainda há muito espaço para evoluir, e é justamente por isso que a participação da comunidade é tão valiosa. Testes em projetos reais, relatos de incompatibilidade, sugestões de jornadas e exemplos de uso ajudam a definir os próximos passos de forma muito mais concreta do que qualquer roadmap isolado.
Experimente o RadIA 2.2.1
Se você trabalha com Delphi, convido você a instalar a versão atual e testar o RadIA em uma tarefa real: corrigir um build, criar uma suíte DUnitX, investigar uma exceção, reproduzir um problema de interface ou analisar um vazamento de memória com FastMM5.
O projeto é open source. Você pode acompanhar o código, consultar a documentação, baixar o instalador e participar pelo GitHub:
- Repositório: https://github.com/regyssilveira/RadIA-Plugin
- Última release: https://github.com/regyssilveira/RadIA-Plugin/releases/latest
Se o RadIA for útil para você, deixe uma estrela no repositório. Além de apoiar o projeto, a estrela ajuda outros desenvolvedores Delphi a descobrirem que hoje já existe uma plataforma de IA capaz de participar da jornada completa — do primeiro arquivo ao diagnóstico e à validação final.
0 comentário(s)