convez.ai
SkillAutomaçãoAvançado
Sahil-SS9

Hermes Simplify Swarm

Sahil-SS9/hermes-simplify-swarm

Limpeza profunda de código com análise de risco multi-agente

Ver no GitHub
InicialPluginScore · de 0 a 100

Skill multi-agente para simplificação de código no Hermes Agent com três sub-agentes paralelos (Hygiene, Clarity, Correctness) que analisam diffs sob diferentes ângulos. Classifica achados por risco (SAFE, CAREFUL, RISKY) e aplica com precisão cirúrgica, detectando code smell, N+1 queries, vazamentos de memória e anti-patterns de concorrência.

Instalação

$npx convez-ai Sahil-SS9/hermes-simplify-swarm

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
25
Forks
0
Acompanhando
0
Saúde
42%
Último commit
há 3 meses
Versão
—
Issues abertas
0
Contribuidores
1

Casos de uso

  • Revisar mudanças antes de PRs com detecção de padrões ocultos
  • Identificar débito técnico em código herdado ou gerado por IA
  • Automatizar remoção de dead code, duplicação e abstrações redundantes
  • Flagear problemas críticos (vazamento de memória, race conditions) para revisão humana

Veredito

Skill bem arquitetada que vai além de linters: combina análise estática com semântica de risco, detectando anti-patterns que ferramentas genéricas perdem. Excelente para times que herdam código ou usam IA na geração; requer disciplina para agir apenas nos achados SAFE sem bloquear fluxo.

README

A tradução para o português deste README ainda está na fila.

Simplify Swarm — Multi-Agent Code Simplification for Hermes Agent

Most code simplification tools check for style violations and linting. Simplify Swarm breaks your code down into risk tiers and cleans with surgical precision.

Three parallel subagents attack your diff from different angles: Hygiene hunts dead code, AI slop, pass-through wrappers, and stale state — the stuff that rots silently. Clarity goes after duplication, naming rot, nested ternaries, and structural bloat — the stuff that makes your teammates sigh. Correctness traces N+1 queries, memory leaks, concurrency races, leaky abstractions, and silent failures — the stuff that breaks at 3am.

Then a consolidator merges, de-duplicates, and triages everything into a risk-tiered application order: SAFE (auto-applied — unused imports, dead branches), CAREFUL (applied with test verification — renames, extracted helpers), RISKY (flagged for human review — N+1 restructures, public API changes, concurrency fixes).

It's read-only during analysis — finds problems, doesn't touch your code until you've seen the consolidated report. Opt-in only, no auto-trigger. Run /simplify when you want to know what you actually shipped.

Built by synthesising 11 implementations: Anthropic's official code-simplifier plugin, nicknisi's essentials fork (AI slop detection, dead code removal), Navigator's ROI-gated config-driven approach, Addy Osmani's language-specific guidance and Chesterton's Fence, OMC's ai-slop-cleaner and 4-pass workflow, ECC's refactor-cleaner (knip/depcheck/ts-prune), WalletConnect's early-return patterns, Meta OpenEnv's TDD Red-Green-Refactor integration, GitHub Copilot's structured output format, and the Claude Code /simplify stop-hook architecture.

Langauge-specific detectors for TypeScript/JavaScript, Python, and Go. N+1 query patterns. Memory leak signatures. Concurrency anti-patterns. Silent failure spots. All the things a general-purpose reviewer misses because it's looking too broad.

Companion to Hermes Agent's built-in simplify-code skill. That one's 175 lines, general-purpose, fast. This one's the deep clean — use it before PRs, before deploys, when you inherit code you don't trust.

Upstream enhancement PR is open with the 5 highest-value additions (risk-tiered application, Chesterton's Fence, AI slop detection, silent failure detection, structured output): https://github.com/NousResearch/hermes-agent/compare/main...Sahil-SS9/KenseiAgent:feat/enhance-simplify-code

If you write a skill that pairs with this (CI integration, auto-test generator for findings, language pack for Rust/Zig/Kotlin), open a PR. Bug reports appreciated. If the Correctness agent flagged your code and you're annoyed — it's designed to be thorough.

Installation

mkdir -p ~/.hermes/skills/software-development
cd ~/.hermes/skills/software-development
git clone https://github.com/Sahil-SS9/hermes-simplify-swarm.git simplify-swarm

No dependencies. No config required. Works on any Hermes Agent install.

Quick Start

"simplify my changes"
/cleanup
"deslop this module"
"/simplify focus on correctness"

The skill auto-detects scope via git diff. SAFE changes applied automatically. CAREFUL changes applied with test verification. RISKY findings flagged for you to decide.

The Three Agents

AgentWhat It HuntsExamples
Hygiene (SAFE)Dead code, AI slop, redundant abstractions, stale state, utility discoveryUnused imports, as any casts, pass-through wrappers, duplicate state stores
Clarity (CAREFUL)Duplication, naming, structure, consistencyNested ternaries, data/temp variables, 80-line functions, mixed arrow/function styles
Correctness (RISKY)N+1 queries, memory leaks, concurrency, leaky abstractions, silent failuresORM queries in loops, unclosed resources, race conditions, empty catch blocks

Configuration

Optional .kensei/simplify.yaml in your project root:

simplify:
  auto_apply: true          # Skip approval for SAFE+CAREFUL tiers
  skip_patterns:
    - "*.test.*"
    - "*.generated.*"
  max_file_lines: 800

Credits

Built by Sahil Saghir (KENSEI). Inspired by Claude Code's /simplify and the upstream Hermes Agent simplify-code skill.

License

MIT — use it, fork it, ship it.

Ver o original no GitHub

Bom para

Relacionados