convez.ai
PluginProdutividadeAvançado
parasxos

cpp26-adapter

parasxos/cpp26-adapter

Especialista em C++26 com idiomas modernos e verificação em tempo real

Ver no GitHub
InicialPluginScore · de 0 a 100

Plugin que transforma Claude em especialista em C++26, gerando código alinhado ao padrão ISO/IEC 14882:2026. Oferece sugestões orientadas pelo padrão com verificação honesta do compilador, cobrindo reflection, contracts, senders, inplace_vector e #embed.

Instalação

$npx convez-ai parasxos/cpp26-adapter

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
4
Forks
0
Acompanhando
1
Saúde
71%
Último commit
há 5 meses
Versão
v1.0.0
Issues abertas
0
Contribuidores
1

Casos de uso

  • Gerar código C++26 com reflection e contracts
  • Migrar padrões legados para idiomas modernos do C++26
  • Verificar conformidade com ISO/IEC 14882:2026

Veredito

Ferramenta sólida e bem-engineered para quem trabalha com C++26 em produção. Cobre gaps reais entre compiladores e padrão final, com avaliação honesta (90% de acurácia). Recomendado para times que precisam estar à frente do padrão.

README

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

cpp26-adapter

Turn your LLM coding assistant into a C++26 specialist. A Claude Code plugin (and standalone MCP server) that biases generation toward ISO/IEC 14882:2026 final-form idioms — reflection, contracts, senders, inplace_vector, #embed — even when your local clang hasn't caught up.

ci version pypi eval bar standard code license

Quick Start

Full plugin (Claude Code — skill + MCP + reviewer + hooks + slash command):

/plugin marketplace add parasxos/claude-plugins
/plugin install cpp26-adapter@parasxos/claude-plugins

MCP server only (any MCP-compatible client):

pip install cpp26-ref

What it does

Six concrete idiom shifts on the same prompts a vanilla LLM would answer with pre-C++26 patterns:

You ask for…Vanilla LLM emitscpp26-adapter emits
enum → stringX-macros / magic_enumstd::meta::enumerators_of(^^E) + template for
preconditionassert(x > 0)pre(x > 0) / contract_assert(...)
async pipelinestd::async(...)ex::just | ex::then | ex::sync_wait
fixed-capacity vectorboost::static_vectorstd::inplace_vector<T, N>
embed binary assetobjcopy / xxd / incbin#embed "asset.bin"
Nth pack elementstd::get<N>(std::forward_as_tuple(args...))args...[N]

The hook — ask for "enum to string"

Vanilla falls back to X-macros. With cpp26-adapter — straight from P2996 reflection + P1306 expansion statements:

template <typename E> requires std::is_enum_v<E>
constexpr std::string_view enum_name(E v) {
    template for (constexpr auto e :
                  std::define_static_array(std::meta::enumerators_of(^^E))) {
        if (v == [: e :]) return std::meta::identifier_of(e);
    }
    return "<unknown>";
}

No macros. No third-party dep. No codegen. More side-by-side examples (contracts, senders, #embed): docs/examples.md.

Compatible clients

ClientRecommended path
Claude Code/plugin install (full plugin: skill + MCP + reviewer + hooks)
Claude Desktopcpp26-ref MCP server via stdio (config below)
Cursorcpp26-ref MCP server via stdio
VS Code (Cline / Continue)cpp26-ref MCP server via stdio
Any other MCP clientcpp26-ref MCP server via stdio

Configuration

Claude Code

After /plugin install cpp26-adapter@parasxos/claude-plugins, everything wires itself up: the skill loads into context, the MCP starts on demand, the reviewer subagent is callable as @cpp26-reviewer, the hook lints on every C++ edit, and /cpp26-init is available.

Claude Desktop

Add to ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):

{
  "mcpServers": {
    "cpp26-ref": {
      "command": "cpp26-ref"
    }
  }
}

Requires pip install cpp26-ref on a Python (≥3.11) reachable from the Claude Desktop process.

Cursor / VS Code / generic MCP client

{
  "mcpServers": {
    "cpp26-ref": { "command": "cpp26-ref" }
  }
}

Verify the install

After install + restart, three sanity checks:

  1. Ask the assistant "write enum-to-string for enum class E { A, B }" — the response should use std::meta reflection, not X-macros or magic_enum.
  2. (Full plugin only) Run @cpp26-reviewer src/foo.cpp — should return a YAML report with status: pass | needs-changes | compiler-lag-only.
  3. (Full plugin only) Run /cpp26-init in an empty directory — the scaffolded CMakeLists.txt should build a #include <print> + std::print("hi\n") hello-world.

MCP tools

The cpp26-ref server exposes three stdio tools over MCP, in-memory over 216 indexed C++26 papers (no SQLite, no embeddings, no build step):

ToolSignatureReturns
lookup_paper(paper_id: str) — e.g. "P2996"Full reference: title, problem statement, key syntax, canonical example, pre-C++26 equivalent, gotchas, related papers
search(query: str, limit: int = 5)Top-N papers ranked by rapidfuzz partial-ratio against title + frontmatter
compiler_status(paper_id: str)Per-compiler implementation status: none/partial/shipped × clang / gcc / msvc / clang-p2996 with version cutoffs

Cold start ~352 ms. 17 tests pass under pytest mcp-server/tests.

Use cases

Generate idiomatic C++26 code. Ask for new code — the skill biases the model toward the C++26 idiom before generation, so you get pre(...) instead of assert(...), std::execution instead of std::async, reflection instead of X-macros, without re-prompting.

Review existing code for C++26 modernization. Run @cpp26-reviewer src/foo.cpp — the subagent runs a two-pass review: regex anti-patterns first, then clang -std=c++2c -fsyntax-only, classifying each diagnostic as compiler-lag (paper adopted, compiler incomplete) or bug (genuine code error). You see both axes side by side.

Initialize a new C++26 project. Run /cpp26-init — scaffolds CMakeLists.txt (CXX_STANDARD 26, -std=c++2c, CMAKE_EXPORT_COMPILE_COMMANDS ON), .clangd, and .cpp26-adapter.yaml.

Get authoritative paper references. The lookup_paper MCP tool returns the canonical paper text — useful when you need to cite or quote a paper, or when you want the LLM to ground its answer in the actual proposal rather than its (often stale) training data.

The invariant

Recommendations follow the standard, not the toolchain. If clang < 22 / gcc < 16 haven't shipped a feature, the plugin still suggests the C++26 form. Compiler errors are surfaced as compiler-lag or bug — never auto-rewritten into a pre-C++26 workaround.

The suggestion path (skill + MCP) is compiler-agnostic; compiler awareness lives only in the reviewer's Pass-2 syntax check and the SessionStart probe. Full architecture diagram: docs/architecture.md.

Eval

37/39 (95%) with plugin ON vs 14/39 (36%) OFF on a 39-task held suite; bar ≥85%. Per-task scoring + methodology: eval/results-v0.9.0.md, docs/papers.md.

Status

v1.0.0 — eval gate held across two successive refreshes. The MCP tool signatures, the subagent's output schema, and the standard-first invariant are contract-binding for the 1.x line.

License

Dual-licensed by directory:

See also

Ver o original no GitHub

Bom para

Relacionados