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:

1. o agente apresenta um plano antes de alterar qualquer coisa;
2. cada operação respeita risco, consentimento e limites do workspace;
3. o trabalho produz evidências, como diff, resultado de build, testes e estado do debugger;
4. 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.