@m-velikov/cpp-quick-start-mcp 0.1.0

package/data/scaffold-github-actions/SKILL.md

@@ -0,0 +1,29 @@
+---
+name: scaffold-github-actions
+description: Generates a standard GitHub Actions CI pipeline for a C++ project.
+---
+
+# GitHub Actions Scaffolding Skill
+
+This skill instructs the agent on how to scaffold a CI pipeline using GitHub Actions.
+
+## Requirements
+
+When the user specifies GitHub Actions for their CI Provider, the agent MUST generate a workflow file at `.github/workflows/build.yml`.
+
+## Instructions for `build.yml`
+
+The generated workflow must:
+
+1. **Trigger**: Run on `push` and `pull_request` to the `main` or `master` branch.
+2. **Strategy Matrix**: Test across multiple OS environments if applicable (e.g., `ubuntu-latest`, `macos-latest`, `windows-latest`).
+3. **Steps**:
+   - Check out the repository (`actions/checkout@v4`).
+   - Setup the compiler and dependencies (e.g., install ninja, CMake).
+   - Configure the build using the chosen build system (e.g., `cmake -B build -G Ninja`).
+   - Build the project (e.g., `cmake --build build`).
+   - Run tests (e.g., `ctest --test-dir build --output-on-failure`).
+
+## Workflow Integration
+
+This skill is utilized by the `meta-quickstart` skill when the user selects GitHub Actions as their CI Provider.

package/data/scaffold-gitlab-ci/SKILL.md

@@ -0,0 +1,30 @@
+---
+name: scaffold-gitlab-ci
+description: Generates a standard GitLab CI pipeline for a C++ project.
+---
+
+# GitLab CI Scaffolding Skill
+
+This skill instructs the agent on how to scaffold a CI pipeline using GitLab CI.
+
+## Requirements
+
+When the user specifies GitLab CI for their CI Provider, the agent MUST generate a pipeline file at `.gitlab-ci.yml` in the root of the project.
+
+## Instructions for `.gitlab-ci.yml`
+
+The generated pipeline must:
+
+1. **Image**: Use a standard C++ docker image (e.g., `gcc:latest` or `silkeh/clang:latest`).
+2. **Stages**: Define at least two stages: `build` and `test`.
+3. **Build Job**:
+   - Install necessary dependencies (e.g., `apt-get update && apt-get install -y cmake ninja-build`).
+   - Configure and build the project.
+   - Save the build artifacts.
+4. **Test Job**:
+   - Depend on the build job.
+   - Run the testing suite (e.g., `ctest --output-on-failure`).
+
+## Workflow Integration
+
+This skill is utilized by the `meta-quickstart` skill when the user selects GitLab CI as their CI Provider.

package/data/scaffold-gtest/SKILL.md

@@ -0,0 +1,53 @@
+---
+name: scaffold-gtest
+description: Generates boilerplate for Google Test (GTest) framework integration.
+---
+
+# GTest Scaffolding Skill
+
+This skill instructs the agent on how to scaffold Google Test (GTest) for a C++ project.
+
+## Requirements
+
+When the user specifies GTest for their Testing Framework, you MUST generate the necessary boilerplate to integrate it with the chosen build system and package manager.
+
+## Instructions for CMake
+
+If the Build System is CMake:
+
+1. **Fetching GTest**: If the user didn't specify a package manager (or specifies FetchContent), use CMake's `FetchContent` to download GTest:
+   ```cmake
+   include(FetchContent)
+   FetchContent_Declare(
+     googletest
+     URL https://github.com/google/googletest/archive/03597a01ee50ed33e9dfd640b249b4be3799d395.zip
+   )
+   # For Windows: Prevent overriding the parent project's compiler/linker settings
+   set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
+   FetchContent_MakeAvailable(googletest)
+   ```
+2. **Linking**: Link test executables against `GTest::gtest_main` and `GTest::gmock`.
+   ```cmake
+   add_executable(my_test test_main.cpp)
+   target_link_libraries(my_test PRIVATE GTest::gtest_main GTest::gmock my_library)
+   ```
+3. **Test Discovery**: Include `GoogleTest` and use `gtest_discover_tests()` to automatically discover tests for CTest.
+   ```cmake
+   include(GoogleTest)
+   gtest_discover_tests(my_test)
+   ```
+
+## Instructions for Source Files
+
+Generate a basic test file `test_main.cpp` using the `TEST` macro:
+
+```cpp
+#include <gtest/gtest.h>
+
+TEST(ExampleTest, BasicAssertions) {
+    EXPECT_EQ(1, 1);
+    EXPECT_TRUE(true);
+}
+```
+
+_Note: If linking against `GTest::gtest_main`, no `main()` function is required in the test file._

package/data/scaffold-make/SKILL.md

@@ -0,0 +1,62 @@
+---
+name: scaffold-make
+description: Generates modern Makefiles for configuring a C++ project.
+---
+
+# Makefile Scaffolding Skill
+
+This skill instructs the agent on how to scaffold a `Makefile` for a C++ project.
+
+## Requirements
+
+When the user specifies Makefiles for the Build System, the agent MUST generate a single root `Makefile`. Do NOT generate recursive Makefiles (e.g., invoking `$(MAKE)` in subdirectories for sub-components). Use a non-recursive design (e.g., including `.mk` files) for better dependency tracking and performance.
+
+## Instructions
+
+1. **Non-Recursive Design**: Always use a non-recursive Makefile architecture. Include source files from subdirectories directly or via `include` statements.
+2. **Compiler and Flags**: Define `CXX`, `CXXFLAGS`, and `LDFLAGS`. Use modern defaults.
+   ```makefile
+   CXX ?= g++
+   CXXFLAGS ?= -std=c++17 -Wall -Wextra -Wpedantic -O2
+   LDFLAGS ?=
+   ```
+3. **Directories**: Define `SRC_DIR`, `OBJ_DIR`, and `BIN_DIR`.
+   ```makefile
+   SRC_DIR := src
+   OBJ_DIR := obj
+   BIN_DIR := bin
+   ```
+4. **Source Discovery**: Automatically discover source files or list them explicitly.
+   ```makefile
+   SRCS := $(wildcard $(SRC_DIR)/**/*.cpp)
+   OBJS := $(patsubst $(SRC_DIR)/%.cpp, $(OBJ_DIR)/%.o, $(SRCS))
+   ```
+5. **Targets**: Create rules for the executable(s) and object files.
+
+   ```makefile
+   TARGET := $(BIN_DIR)/my_app
+
+   all: $(TARGET)
+
+   $(TARGET): $(OBJS)
+   	@mkdir -p $(@D)
+   	$(CXX) $(OBJS) -o $@ $(LDFLAGS)
+
+   $(OBJ_DIR)/%.o: $(SRC_DIR)/%.cpp
+   	@mkdir -p $(@D)
+   	$(CXX) $(CXXFLAGS) -c $< -o $@
+
+   clean:
+   	rm -rf $(OBJ_DIR) $(BIN_DIR)
+
+   .PHONY: all clean
+   ```
+
+## Build Skills Generation
+
+If Makefile is the build system, the agent MUST generate a `skills/build-project/SKILL.md` in the new project.
+The generated skill must instruct agents to build the project using:
+
+```bash
+make -j
+```

package/data/scaffold-meson/SKILL.md

@@ -0,0 +1,49 @@
+---
+name: scaffold-meson
+description: Generates modular meson.build files for configuring a C++ project.
+---
+
+# Meson Scaffolding Skill
+
+This skill instructs the agent on how to scaffold a modern, modular Meson build structure for the C++ project.
+
+## Requirements
+
+When the user specifies Meson for the Build System, the agent MUST generate a root `meson.build` and any necessary subdirectory `meson.build` files (e.g., in `src/` or `tests/`).
+
+## Instructions for `meson.build`
+
+**If generating a NEW project (Mode A):**
+
+1. **Project Definition**: Start the root `meson.build` with:
+   `project('ProjectName', 'cpp', version : '0.1.0', default_options : ['warning_level=3', 'cpp_std=c++20'])`
+   Adjust the `cpp_std` according to the user's choice.
+2. **Modularity (CRITICAL RULE)**: Do NOT define libraries or executables in a single monolithic top-level `meson.build`. The root `meson.build` MUST only use `subdir('dir')` for each target. The actual `library()` or `executable()` calls MUST be placed inside individual `meson.build` files residing in their respective target source directories.
+3. **Dependency Management**: Use `dependency('<name>')` to link dependencies.
+   - **External Package Managers (Conan/vcpkg)**: If the user chose Conan or vcpkg, assume dependencies will be resolved via `pkg-config`. (e.g. `dependency('fmt')`).
+   - **Native Meson Wraps**: If no external package manager is used, instruct the AI to scaffold `.wrap` files for the requested dependencies inside the `subprojects/` directory, and use `dependency('fmt', fallback: ['fmt', 'fmt_dep'])`.
+4. **Target Definitions**: In the subdirectory `meson.build` files:
+   - For libraries, use `library('name', sources, dependencies : [...])`.
+   - For executables, use `executable('name', sources, dependencies : [...])`.
+   - If an executable tool depends on a library built in the same project, link them by creating a `declare_dependency` for the library or passing the library target directly in `link_with`.
+5. **Testing**: If a testing framework is chosen, create a `tests/` directory with a `meson.build` file containing `test('test_name', test_exe)`. Download the testing framework (e.g., GTest, Catch2) via a `.wrap` file if no external package manager handles it.
+6. **IDE Support**: Meson inherently generates `compile_commands.json` in the build directory, so no special build system flags are required. Our standard `.clangd` file configuration will seamlessly discover it.
+
+**If adding components to an EXISTING project (Mode B):**
+
+1. **DO NOT OVERWRITE**: You MUST NOT overwrite existing `meson.build` files entirely.
+2. **Safe Appending**: Append the new `subdir('<target_name>')` calls to the root `meson.build` and create the new folder with its own isolated `meson.build` file.
+
+## Build Skills Generation
+
+If Meson is the build system, the agent MUST generate a `skills/build-project/SKILL.md` in the new project.
+The generated skill must instruct agents to build the project using:
+
+```bash
+meson setup build
+meson compile -C build
+```
+
+## Workflow Integration
+
+This skill is utilized by the `meta-quickstart` skill when the user selects Meson as their build system.

package/data/scaffold-pitchfork-layout/SKILL.md

@@ -0,0 +1,60 @@
+---
+name: scaffold-pitchfork-layout
+description: Generates a C++ project directory structure strictly following the Pitchfork Layout specification.
+---
+
+# Pitchfork Layout Scaffolding Skill
+
+This skill instructs the agent on how to correctly scaffold a C++ project following the official Pitchfork directory layout specification.
+
+## Reference
+
+For the exact specification and rationale, always refer to the official documentation:
+[Pitchfork Layout Specification](https://github.com/vector-of-bool/pitchfork/blob/develop/data/spec.bs)
+
+## Standard Directories to Create
+
+When invoking this skill to scaffold a new C++ project, the agent MUST create the following structure based on the Pitchfork standard:
+
+1. **`src/`** or **`libs/` / `tools/`**:
+   - For a single library/executable, use `src/` for private implementation files (`*.cpp`, private `*.hpp`).
+   - **For multiple targets** (e.g., a core library and multiple CLI tools), the agent MUST group them properly. Either use target-specific subdirectories inside `src/` (e.g., `src/core_lib/`, `src/app_cli/`) or use the top-level `libs/` and `tools/` directories as per Pitchfork (e.g., `libs/core_lib/src/`, `tools/app_cli/src/`).
+2. **`include/`**: Contains the public headers API.
+   - **CRITICAL**: Do NOT place headers directly in `include/`. You must create a subdirectory matching the target name (e.g., `include/<target_name>/`). This prevents header collisions. For multiple libraries, create multiple subdirectories (e.g., `include/libA/`, `include/libB/`).
+3. **`tests/`**: Contains all testing code. For multiple targets, group tests by target (e.g., `tests/libA/`, `tests/libB/`).
+4. **`examples/`** _(Optional)_: Contains example code showing how to use the library/project.
+5. **`external/`** _(Optional)_: Contains third-party dependencies (if not using a package manager like vcpkg or FetchContent).
+6. **`data/`** _(Optional)_: Contains non-source data files (e.g., assets, images, databases).
+7. **`tools/`** _(Optional)_: Contains development scripts, deployment scripts, and internal utilities.
+8. **`docs/`** _(Optional)_: Contains project documentation (e.g., Doxygen configuration).
+9. **`build/`**: The designated output directory for build artifacts (compilation should always be out-of-source). This directory should be added to `.gitignore`.
+
+## Example Structure (Multi-Target)
+
+If building a project with a library `core_lib` and an executable `app_cli`, the layout should look like this:
+
+```
+my_project/
+├── CMakeLists.txt
+├── .gitignore
+├── include/
+│   └── core_lib/
+│       └── core_lib.hpp
+├── src/
+│   ├── core_lib/
+│   │   └── core_lib.cpp
+│   └── app_cli/
+│       └── main.cpp
+└── tests/
+    └── core_lib/
+        └── test_core_lib.cpp
+```
+
+## Existing Project Additions (Mode B)
+
+If adding new components to an _existing_ project, the agent MUST NOT delete, overwrite, or reorganize existing directories unless a layout refactoring plan has been explicitly proposed and approved by the user (as determined by the Layout Conformity Check).
+If no refactoring plan was approved, safely _add_ the new component directories alongside the existing ones, strictly following the inferred layout (e.g., creating `src/<new_target>/` and `include/<new_target>/`).
+
+## Workflow Integration
+
+This skill is utilized by the `meta-quickstart` skill when a user selects "Pitchfork" as their desired directory layout, or when an existing project is inferred to use Pitchfork conventions. The agent generating the final project should use the rules above to create the file tree.

package/data/scaffold-pre-commit/SKILL.md

@@ -0,0 +1,33 @@
+---
+name: scaffold-pre-commit
+description: Generates .pre-commit-config.yaml for C++ projects.
+---
+
+# Pre-Commit Scaffolding Skill
+
+This skill instructs the agent on how to scaffold a `.pre-commit-config.yaml` file for a C++ project.
+
+## Requirements
+
+When the user specifies Pre-Commit hooks for Code Quality, the agent MUST generate a `.pre-commit-config.yaml` file in the project root.
+
+## Instructions
+
+1. **Configuration File**: Create a `.pre-commit-config.yaml` with common C++ hooks.
+   ```yaml
+   repos:
+     - repo: https://github.com/pre-commit/pre-commit-hooks
+       rev: v4.4.0
+       hooks:
+         - id: trailing-whitespace
+         - id: end-of-file-fixer
+         - id: check-yaml
+     - repo: https://github.com/pre-commit/mirrors-clang-format
+       rev: v16.0.2
+       hooks:
+         - id: clang-format
+   ```
+2. **Installation Instructions**: In the generated build or configuration skill, instruct the agent to note that the user should install pre-commit hooks:
+   ```bash
+   pre-commit install
+   ```

package/data/scaffold-vcpkg/SKILL.md

@@ -0,0 +1,50 @@
+---
+name: scaffold-vcpkg
+description: Generates a vcpkg.json manifest for configuring packaging and dependency management with vcpkg.
+---
+
+# vcpkg Packaging Skill
+
+This skill instructs the agent on how to scaffold a vcpkg manifest (`vcpkg.json`) for the C++ project.
+
+## Requirements
+
+When the user specifies vcpkg for Project Packaging or Dependency Management, the agent MUST generate a `vcpkg.json` file in the root of the project.
+
+## Instructions for `vcpkg.json`
+
+The `vcpkg.json` file must be a valid JSON containing:
+
+1. `"$schema"`: Pointing to the vcpkg schema URL.
+2. `"name"`: The project name (lowercase).
+3. `"version-string"` or `"version"`: The project version.
+4. `"description"`: A brief description of the library/application.
+5. `"dependencies"`: An array of strings or objects representing the third-party dependencies required.
+
+### Example Manifest:
+
+```json
+{
+  "$schema": "https://raw.githubusercontent.com/microsoft/vcpkg-tool/main/docs/vcpkg.schema.json",
+  "name": "my-library",
+  "version": "1.0.0",
+  "description": "My awesome C++ library",
+  "dependencies": ["fmt", "nlohmann-json"]
+}
+```
+
+## `vcpkg-configuration.json` (Optional)
+
+If the project requires pinning dependencies to specific baselines or using custom registries, instruct the agent to also generate a `vcpkg-configuration.json` file alongside the manifest.
+
+## Configure Skills Generation
+
+If vcpkg is used with CMake, the agent MUST instruct that the generated `skills/configure-project/SKILL.md` inside the new project contains the exact instructions for passing the vcpkg toolchain to CMake. For example:
+
+```bash
+cmake -B build -S . -DCMAKE_TOOLCHAIN_FILE=[path to vcpkg]/scripts/buildsystems/vcpkg.cmake
+```
+
+## Workflow Integration
+
+This skill is utilized by the `meta-quickstart` skill when the user selects vcpkg for Project Packaging or Dependency Management.

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@m-velikov/cpp-quick-start-mcp",
+  "version": "0.1.0",
+  "description": "An MCP server for scaffolding modern C++ projects and agentic configurations.",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/m-velikov/cpp-quick-start-mcp.git"
+  },
+  "main": "build/index.js",
+  "bin": {
+    "cpp-quick-start-mcp": "build/index.js"
+  },
+  "files": [
+    "build",
+    "data"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "start": "node build/index.js",
+    "format": "prettier --write \"src/**/*.ts\" \"data/**/*.md\"",
+    "lint": "eslint src/**/*.ts"
+  },
+  "keywords": [
+    "mcp",
+    "c++",
+    "scaffold",
+    "cmake",
+    "vcpkg",
+    "conan"
+  ],
+  "author": {
+    "name": "Momchil Velikov",
+    "email": "momchil.velikov@gmail.com",
+    "url": "https://github.com/m-velikov"
+  },
+  "license": "MIT",
+  "type": "module",
+  "engines": {
+    "node": ">=18.3.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@hono/node-server": "^2.0.4",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "hono": "^4.12.23"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.14.0",
+    "@types/node": "^25.9.1",
+    "eslint": "^9.14.0",
+    "prettier": "^3.8.3",
+    "tsx": "^4.22.3",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.13.0"
+  }
+}