RadIA 2.8.0: assistência semântica integrada ao editor Delphi

O RadIA 2.8.0 é uma release de integração fina com o editor Delphi.

Depois da versão 2.7.0 consolidar uma base funcional mais previsível, com criação de projetos por linguagem natural, navegação Code/Design, revisão por bloco e evidências reproduzíveis, a 2.8.0 avança em uma camada mais próxima do uso diário: o contexto semântico do editor.

Essa evolução é importante porque, na prática, a qualidade de uma resposta de IA dentro da IDE depende muito do contexto que ela recebe. Não basta saber que existe um projeto Delphi aberto. É preciso entender qual unit está ativa, qual símbolo está sob o cursor, quais imports estão disponíveis e quais declarações próximas ajudam a explicar a intenção do usuário.

Ao mesmo tempo, esse tipo de integração precisa ser cuidadoso. O editor Delphi já possui seu próprio CodeInsight e sua própria experiência nativa. O objetivo do RadIA 2.8.0 não é substituir isso, mas complementar o fluxo com uma camada observável, limitada e segura de contexto para a IA.

O problema: IA sem contexto local fica genérica demais

Quem usa IA para programar conhece bem o padrão: quando o contexto enviado é pobre, a resposta fica genérica. O modelo pode explicar conceitos, sugerir caminhos e gerar exemplos, mas muitas vezes erra detalhes simples porque não sabe exatamente onde o usuário está no código.

Em Delphi, isso é ainda mais sensível. Uma unit pode ter convenções próprias, uses específicos, classes parciais entre .pas e .dfm, métodos de evento, componentes visuais, helpers, records e padrões de arquitetura do projeto. Sem olhar para o entorno correto, a IA tende a responder como se estivesse em um exemplo isolado.

O RadIA 2.8.0 melhora esse ponto criando um contexto semântico compartilhado do editor. Esse contexto não tenta analisar o projeto inteiro nem fingir que entende tudo. Ele faz algo mais pragmático: coleta um recorte útil, limitado e inspecionável do buffer vivo.

Esse recorte inclui informações como unit atual, símbolo no cursor, imports e declarações próximas. É o bastante para melhorar ações comuns sem transformar cada interação em uma varredura pesada do projeto inteiro.

Ghost Text, ações contextuais e agente olhando para a mesma base

A principal mudança da 2.8.0 é que Ghost Text, ações contextuais e agente passam a usar o mesmo analisador de contexto.

Isso reduz divergência entre experiências. Antes, cada superfície poderia se comportar como se tivesse uma leitura ligeiramente diferente do editor. Agora, a intenção é que a sugestão inline, uma ação de menu como explicar ou localizar bugs, e uma ferramenta agentiva partam da mesma base semântica.

Na prática, isso torna o comportamento mais consistente.

Se o cursor está sobre um método, as ações relacionadas ao editor têm mais chance de entender aquele método como o foco. Se a unit possui imports relevantes, esse dado acompanha o contexto. Se existem declarações próximas que ajudam a explicar o trecho, elas podem ser consideradas sem exigir que o usuário selecione manualmente tudo.

O ganho não é apenas técnico. É ergonomia. O desenvolvedor não precisa ficar descrevendo o que a IDE já poderia informar.

Show Semantic Editor Context

Uma ferramenta de IA integrada à IDE precisa ser transparente. Por isso, a 2.8.0 adiciona a ação Show Semantic Editor Context.

Ela permite inspecionar os metadados coletados em modo somente leitura. Isso é muito útil por dois motivos.

O primeiro é confiança. O usuário consegue ver qual contexto está sendo considerado antes de depender dele em uma ação mais sofisticada.

O segundo é suporte e diagnóstico. Quando uma resposta parece fora do esperado, é possível verificar se o RadIA estava olhando para o símbolo correto, a unit correta e o recorte correto do buffer.

Esse ponto parece pequeno, mas é um sinal de maturidade. Sistemas agentivos ficam melhores quando suas decisões são observáveis. Uma IA opaca pode até impressionar em uma demonstração, mas uma ferramenta usada no dia a dia precisa permitir inspeção.

Uma nova ferramenta para o agente: GetEditorSemanticContext

A versão 2.8.0 também registra a ferramenta GetEditorSemanticContext.

Ela disponibiliza ao agente o mesmo contexto semântico do editor, classificado como readOnly. Isso significa que a ferramenta existe para leitura e compreensão, não para alterar código.

Esse detalhe é importante. O RadIA vem evoluindo como uma plataforma agentiva dentro do Delphi, com ferramentas para projeto, editor, build, testes, debugger, designer, documentação e diagnóstico. Ao adicionar contexto semântico como uma ferramenta explícita, o projeto torna essa capacidade auditável e reaproveitável.

Em vez de esconder o contexto em uma camada implícita, a 2.8.0 o transforma em parte do catálogo de capacidades. O catálogo desta versão passa a documentar 133 ferramentas internas.

Mais uma vez, o número em si não é o ponto principal. O valor está em organizar capacidades reais, com risco, documentação e uso esperado.

O CodeInsight nativo continua no comando

Um cuidado importante da 2.8.0 é preservar o provider nativo do CodeInsight do Delphi.

Isso precisa ficar claro: o RadIA não está tentando sequestrar o editor nem substituir a infraestrutura padrão da IDE. A assistência semântica adicionada nesta versão é complementar.

O Delphi continua responsável pelo seu CodeInsight nativo. O RadIA usa o contexto do editor para melhorar suas próprias ações de IA, como explicação, geração de testes, localização de bugs, Ghost Text e execução agentiva.

Essa escolha é saudável porque respeita a IDE. Uma integração boa não precisa derrubar o que já funciona. Ela deve se encaixar no fluxo existente e acrescentar valor onde faz sentido.

Para o usuário, o objetivo é simples: continuar usando o Delphi normalmente, mas com ações de IA que entendem melhor o ponto atual do código.

Segurança: contexto limitado, observável e sem mutação

Quando falamos em IA dentro da IDE, segurança operacional não é só sobre credenciais ou rede. Também é sobre preservar o estado de trabalho do desenvolvedor.

Na 2.8.0, a inspeção semântica é limitada e não altera o buffer. Isso evita uma classe inteira de problemas: a ferramenta pode observar o contexto, mas não muda código apenas por estar coletando metadados.

Esse comportamento combina com a filosofia que o RadIA vem adotando nas releases recentes: separar leitura de mutação, exigir consentimento para ações de maior impacto e deixar evidências claras do que foi feito.

É uma diferença importante entre uma automação apressada e um assistente confiável. O assistente pode ser inteligente, mas precisa continuar subordinado ao controle do desenvolvedor.

Por que isso melhora ações como explicar, testar e localizar bugs

Ações comuns do menu do editor ficam melhores quando carregam contexto correto.

Ao explicar código, a IA pode usar o símbolo no cursor e as declarações próximas para evitar respostas abstratas demais. Ao gerar testes, ela consegue considerar melhor a assinatura e o entorno imediato. Ao localizar bugs, pode usar imports e estrutura local para interpretar dependências e padrões do trecho.

Isso não transforma o modelo em compilador nem substitui revisão humana. Mas reduz o atrito de ter que preparar manualmente o prompt perfeito.

O usuário continua podendo selecionar código, escrever instruções e conduzir a conversa. A diferença é que o RadIA passa a levar mais informação relevante junto quando a ação nasce do editor.

Continuidade com a 2.7.0

A 2.8.0 não joga fora a base anterior. Ela se apoia nela.

A versão 2.7.0 foi importante por estabilizar fluxos determinísticos: criação natural de projetos, navegação Code/Design, revisão por bloco com comentários e evidências nos alvos suportados. A 2.8.0 acrescenta contexto semântico compartilhado em cima dessa base.

Isso cria uma progressão interessante.

Primeiro, o RadIA aprende a agir com mais previsibilidade dentro da IDE. Depois, passa a entender melhor o ponto específico onde o usuário está trabalhando.

É exatamente o tipo de evolução que faz sentido para uma ferramenta integrada ao Delphi. Não é uma grande promessa abstrata. É um ajuste de base que melhora várias experiências pequenas, repetidas e importantes.

Validação da release

A release 2.8.0 foi aprovada e liberada em 11 de agosto de 2026.

A auditoria registra:

• contexto semântico compartilhado por Ghost Text, ações contextuais e agente;
• inspeção somente leitura disponível no menu do editor e em Tools;
• ferramenta GetEditorSemanticContext registrada e documentada;
• provider nativo do CodeInsight preservado;
• catálogo gerado com 133 ferramentas documentadas e sincronizadas;
• Delphi 12 Win32 com 1061 testes instrumentados e 8 externos, sem vazamentos;
• Delphi 13 Win32 com 1061 testes instrumentados e 8 externos, sem vazamentos;
• Delphi 13 IDE64 com 1069 testes diretos, sem vazamentos;
• testes web 105/105, ESLint e documentação 41/41;
• SonarQube com quality gate OK, cobertura de 83,2%, duplicação de 1,8% e zero issues;
• pacotes, instalador, evidências, merge, tag e publicação concluídos.

Para um plugin de IDE, esse tipo de matriz importa muito. O RadIA roda dentro do ambiente de trabalho do desenvolvedor. Estabilidade, previsibilidade e validação não são detalhes burocráticos; são parte da experiência.

Como instalar

O caminho recomendado para usuários finais é o instalador visual da release:

RadIA-v2.8.0-Setup.exe

Antes de instalar ou atualizar, feche todas as instâncias do Delphi. O instalador e o script interno bloqueiam a operação quando encontram bds.exe aberto, justamente para evitar arquivos travados, BPLs carregadas em memória e instalações parcialmente atualizadas.

A release está disponível em:

Baixar o RadIA 2.8.0

O instalador publicado não é assinado por decisão do projeto. O SHA-256 do arquivo é:

7F651E049977E0E84125380CC2346420848FAE99EFFF66B671CE52F722914967

O código-fonte, a documentação, os testes e o histórico completo estão no repositório oficial:

github.com/regyssilveira/RadIA-Plugin

Conclusão

O RadIA 2.8.0 é uma release de aproximação entre IA e editor.

Ela não tenta substituir o Delphi, o CodeInsight ou o julgamento do desenvolvedor. A proposta é mais interessante: fazer com que as ações de IA tenham acesso a um contexto local melhor, limitado, observável e seguro.

Com Ghost Text, ações contextuais e agente compartilhando a mesma leitura semântica, o RadIA fica menos genérico e mais conectado ao ponto real de trabalho.

Esse é um passo importante para transformar IA em uma parte natural do fluxo Delphi. Não como uma janela separada que responde perguntas, mas como uma camada de assistência integrada à IDE, respeitando contexto, consentimento e evidência.

Na prática, a 2.8.0 deixa o RadIA um pouco mais próximo daquilo que uma boa ferramenta de desenvolvimento deve ser: presente quando ajuda, discreta quando não precisa agir e transparente o suficiente para o usuário continuar no controle.