Ferramenta que Fornece Análise de Complexidade de Tempo para Assistentes de IA

O Problema

Modelos de IA de fronteira podem analisar a complexidade de tempo. Mas eles fazem isso lendo seu código, raciocinando sobre ele e queimando tokens no processo. Às vezes, eles acertam. Às vezes, eles dizem com confiança que uma função é O(n) quando na verdade é O(n²) porque há um .contains() escondido dentro de um loop.

E se pulássemos tudo isso e simplesmente fornecêssemos a resposta através de análise estática?

A Solução

Eu construí Time Complexity MCP — um servidor MCP que analisa seu código em ASTs usando tree-sitter, percorre a árvore de sintaxe para detectar padrões de complexidade e relata a Big-O por função com anotações de nível de linha.

Funciona como uma ferramenta que Claude Code ou GitHub Copilot podem chamar sob demanda — sem tokens gastos na análise, apenas resultados estruturados.

GitHub: Luzgan/time-complexity-mcp

O Que Ele Detecta

• Aninhamento de loops — for, while, do-while com rastreamento de profundidade. Loops com limite constante (por exemplo, for i in range(10)) são reconhecidos como O(1)
• Recursão — recursão linear (O(n)) vs recursão ramificada como fibonacci (O(2^n))
• Métodos conhecidos da stdlib — .sort() como O(n log n), .filter()/.map() como O(n), .push()/.pop() como O(1). Cada linguagem tem seu próprio conjunto de padrões
• Complexidade combinada — um .indexOf() dentro de um for loop relata corretamente O(n²), não O(n)

Suporta JavaScript, TypeScript, Python, Java, Kotlin e Dart.

Como Funciona

Cada linguagem tem uma classe de analisador que implementa 9 métodos de template de um BaseAnalyzer compartilhado:

1. Parse o arquivo fonte em um AST via tree-sitter
2. Extraia todos os nós de função
3. Para cada função, percorra a árvore para encontrar:
   • Loops (e sua profundidade de aninhamento)
   • Chamadas recursivas (e se elas ramificam)
   • Chamadas conhecidas da stdlib (por exemplo, .sort(), .indexOf())
4. Combine os resultados: um método O(n) dentro de um loop O(n) = O(n²)
5. Retorne resultados estruturados com anotações por linha

Nenhum código é executado — é uma análise estrutural pura.

A Parte Divertida: Auto-Análise

Eu apontei a ferramenta para seu próprio código. 27 arquivos, 150 funções.

A divisão:

Ele encontrou problemas reais:

O scanner de diretório era O(n³) — porque .indexOf() estava sendo chamado dentro de um comparador .sort(), que era chamado após um loop de iteração de arquivo → função aninhado. Um utilitário de formatação era O(n²) pela mesma razão do .indexOf().

Eu corrigi isso com base em seu próprio relatório. Substituí as buscas .indexOf() por um Map para acesso O(1). A ferramenta comeu sua própria comida de cachorro.

Configuração

Baixe uma versão pré-compilada para sua plataforma a partir de GitHub Releases, extraia e adicione à sua configuração MCP:

{
  "mcpServers": {
    "time-complexity": {
      "command": "node",
      "args": ["/path/to/time-complexity-mcp/dist/index.js"]
    }
  }
}

Reinicie o Claude Code e as ferramentas estarão disponíveis. Sem npm install, sem compilador C++ — apenas Node.js 18+.

Ou instale a partir do código-fonte:

git clone https://github.com/Luzgan/time-complexity-mcp.git
cd time-complexity-mcp
npm install && npm run build

O Que Vem a Seguir
Aberto a feedback e solicitações de linguagem. A arquitetura torna fácil adicionar novas linguagens — cada uma tem ~3 arquivos implementando os métodos de template para a estrutura AST daquela linguagem.

Repo: github.com/Luzgan/time-complexity-mcp