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.

Quick Start

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

Code

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

MCP server only (any MCP-compatible client):

Terminal

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 emits	`cpp26-adapter` emits
enum → string	X-macros / `magic_enum`	`std::meta::enumerators_of(^^E)` + `template for`
precondition	`assert(x > 0)`	`pre(x > 0)` / `contract_assert(...)`
async pipeline	`std::async(...)`	`ex::just \| ex::then \| ex::sync_wait`
fixed-capacity vector	`boost::static_vector`	`std::inplace_vector<T, N>`
embed binary asset	`objcopy` / `xxd` / `incbin`	`#embed "asset.bin"`
Nth pack element	`std::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:

cpp

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

Client	Recommended path
Claude Code	`/plugin install` (full plugin: skill + MCP + reviewer + hooks)
Claude Desktop	`cpp26-ref` MCP server via stdio (config below)
Cursor	`cpp26-ref` MCP server via stdio
VS Code (Cline / Continue)	`cpp26-ref` MCP server via stdio
Any other MCP client	`cpp26-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):

config.json

{
  "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

config.json

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

Verify the install

After install + restart, three sanity checks:

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.
(Full plugin only) Run @cpp26-reviewer src/foo.cpp — should return a YAML report with status: pass | needs-changes | compiler-lag-only.
(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):

Tool	Signature	Returns
`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:

Code (everything outside corpus/): MIT — LICENSE-CODE.
Knowledge corpus (corpus/): CC-BY-SA 4.0 — LICENSE-CORPUS.

Cpp26 Adapter README