SHELL := /bin/bash
CARGO = cargo
RUSTFLAGS = -D warnings
RUST_LOG ?= debug
RUST_BACKTRACE ?= 1
RED = \033[0;31m
GREEN = \033[0;32m
YELLOW = \033[1;33m
BLUE = \033[0;34m
NC = \033[0m
.PHONY: all
all: quality-gate
.PHONY: setup
setup:
@echo "$(BLUE)Setting up development environment...$(NC)"
rustup component add rustfmt clippy llvm-tools-preview
cargo install cargo-audit cargo-outdated cargo-machete cargo-deny
cargo install cargo-llvm-cov cargo-nextest cargo-mutants
cargo install pmat @if ! command -v pre-commit &> /dev/null; then \
echo "$(BLUE)Installing pre-commit...$(NC)"; \
pip install pre-commit || echo "$(YELLOW)⚠ Failed to install pre-commit via pip. Please install manually.$(NC)"; \
fi
@echo "$(GREEN)✓ Development environment ready$(NC)"
.PHONY: setup-pre-commit
setup-pre-commit:
@echo "$(BLUE)Setting up Toyota Way pre-commit hooks...$(NC)"
@if ! command -v pre-commit &> /dev/null; then \
echo "$(RED)❌ pre-commit not installed. Run 'make setup' first.$(NC)"; \
exit 1; \
fi
pre-commit install
pre-commit install --hook-type pre-push
pre-commit install --hook-type commit-msg
@echo "$(GREEN)✅ Pre-commit hooks installed with Toyota Way standards$(NC)"
.PHONY: setup-full
setup-full: setup setup-pre-commit
@echo "$(GREEN)🏭 Toyota Way development environment fully configured$(NC)"
.PHONY: wasm-build
wasm-build:
@echo "$(BLUE)Building for WASM target (wasm32-unknown-unknown)...$(NC)"
$(CARGO) build --target wasm32-unknown-unknown --no-default-features --features wasm
@echo "$(GREEN)✓ WASM build complete$(NC)"
.PHONY: wasm-release
wasm-release:
@echo "$(BLUE)Building optimized WASM release...$(NC)"
$(CARGO) build --target wasm32-unknown-unknown --release --no-default-features --features wasm
@echo "$(GREEN)✓ WASM release build complete$(NC)"
.PHONY: cloudflare-sdk-setup
cloudflare-sdk-setup:
@echo "$(BLUE)Setting up Cloudflare Worker with SDK...$(NC)"
@echo "$(GREEN)✓ SDK configuration already in place$(NC)"
.PHONY: cloudflare-sdk-build
cloudflare-sdk-build: cloudflare-sdk-setup
@echo "$(BLUE)Building Cloudflare Worker with SDK...$(NC)"
cd examples/cloudflare-worker-mcp && \
cargo build --target wasm32-unknown-unknown --release --lib
@echo "$(GREEN)✓ Cloudflare Worker SDK build complete$(NC)"
.PHONY: cloudflare-sdk-deploy
cloudflare-sdk-deploy: cloudflare-sdk-build
@echo "$(BLUE)Deploying Cloudflare Worker with SDK...$(NC)"
cd examples/cloudflare-worker-mcp && \
wrangler deploy --name mcp-worker-sdk
@echo "$(GREEN)✓ Cloudflare Worker SDK deployed$(NC)"
.PHONY: cloudflare-sdk-dev
cloudflare-sdk-dev: cloudflare-sdk-setup
@echo "$(BLUE)Starting Cloudflare Worker dev server with SDK...$(NC)"
cd examples/cloudflare-worker-mcp && \
wrangler dev --local
.PHONY: cloudflare-sdk-test
cloudflare-sdk-test:
@echo "$(BLUE)Testing Cloudflare Worker SDK endpoint...$(NC)"
@curl -X POST http://localhost:8787/mcp \
-H "Content-Type: application/json" \
-d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"test","version":"1.0"}}}' \
| jq . || echo "$(YELLOW)⚠ Make sure 'cloudflare-sdk-dev' is running$(NC)"
.PHONY: build-widget-runtime
build-widget-runtime:
@echo "$(BLUE)Building widget-runtime TypeScript library...$(NC)"
@if [ -d "packages/widget-runtime" ] && command -v npm &> /dev/null; then \
cd packages/widget-runtime && npm run build; \
cp dist/browser/browser.mjs ../../crates/mcp-preview/assets/widget-runtime.mjs; \
echo "$(GREEN)✓ widget-runtime built and copied to preview assets$(NC)"; \
else \
echo "$(YELLOW)⚠ Skipping widget-runtime build (missing packages/widget-runtime or npm)$(NC)"; \
fi
.PHONY: clean-widget-runtime
clean-widget-runtime:
@echo "$(BLUE)Cleaning widget-runtime build artifacts...$(NC)"
rm -rf packages/widget-runtime/dist/
rm -f crates/mcp-preview/assets/widget-runtime.mjs
@echo "$(GREEN)✓ widget-runtime cleaned$(NC)"
.PHONY: build
build: build-widget-runtime
@echo "$(BLUE)Building project...$(NC)"
RUSTFLAGS="$(RUSTFLAGS)" $(CARGO) build --all-features
@echo "$(GREEN)✓ Build successful$(NC)"
.PHONY: build-release
build-release: build-widget-runtime
@echo "$(BLUE)Building release...$(NC)"
RUSTFLAGS="$(RUSTFLAGS)" $(CARGO) build --release --all-features
@echo "$(GREEN)✓ Release build successful$(NC)"
.PHONY: fmt
fmt:
@echo "$(BLUE)Formatting code...$(NC)"
$(CARGO) fmt --all
@echo "$(GREEN)✓ Code formatted$(NC)"
.PHONY: fmt-check
fmt-check:
@echo "$(BLUE)Checking code formatting...$(NC)"
$(CARGO) fmt --all -- --check
@echo "$(GREEN)✓ Code formatting OK$(NC)"
.PHONY: lint
lint:
@echo "$(BLUE)Running clippy...$(NC)"
RUSTFLAGS="$(RUSTFLAGS)" $(CARGO) clippy --features "full" --lib --tests -- \
-D clippy::all \
-W clippy::pedantic \
-W clippy::nursery \
-W clippy::cargo \
-A clippy::module_name_repetitions \
-A clippy::must_use_candidate \
-A clippy::missing_errors_doc \
-A clippy::missing_const_for_fn \
-A clippy::return_self_not_must_use \
-A clippy::missing_fields_in_debug \
-A clippy::uninlined_format_args \
-A clippy::if_not_else \
-A clippy::result_large_err \
-A clippy::multiple_crate_versions \
-A clippy::implicit_hasher \
-A clippy::unused_async \
-A clippy::cast_lossless \
-A clippy::redundant_clone \
-A clippy::redundant_closure_for_method_calls \
-A clippy::significant_drop_tightening \
-A clippy::missing_panics_doc \
-A clippy::cast_possible_truncation \
-A clippy::cast_precision_loss \
-A clippy::option_if_let_else \
-A clippy::derive_partial_eq_without_eq \
-A clippy::redundant_else \
-A clippy::match_same_arms \
-A clippy::manual_string_new \
-A clippy::default_trait_access \
-A clippy::format_push_string \
-A clippy::too_many_lines \
-A clippy::cargo_common_metadata \
-A clippy::unused_async_trait_impl
@echo "$(BLUE)Checking examples...$(NC)"
RUSTFLAGS="$(RUSTFLAGS)" $(CARGO) check --features "full" --examples
@echo "$(GREEN)✓ No lint issues$(NC)"
.PHONY: audit
audit:
@echo "$(BLUE)Checking for security vulnerabilities...$(NC)"
$(CARGO) audit
@echo "$(GREEN)✓ No vulnerabilities found$(NC)"
.PHONY: outdated
outdated:
@echo "$(BLUE)Checking for outdated dependencies...$(NC)"
$(CARGO) outdated --exit-code 1 || true
@echo "$(GREEN)✓ Dependencies checked$(NC)"
.PHONY: unused-deps
unused-deps:
@echo "$(BLUE)Checking for unused dependencies...$(NC)"
@echo "$(YELLOW)⚠ cargo machete not installed - skipping$(NC)"
.PHONY: test
test:
@echo "$(BLUE)Running tests...$(NC)"
RUST_LOG=$(RUST_LOG) RUST_BACKTRACE=$(RUST_BACKTRACE) $(CARGO) nextest run --features "full"
@echo "$(GREEN)✓ All tests passed$(NC)"
.PHONY: test-unit
test-unit:
@echo "$(BLUE)Running unit tests (ALWAYS required for new features)...$(NC)"
RUST_LOG=$(RUST_LOG) RUST_BACKTRACE=$(RUST_BACKTRACE) $(CARGO) test --lib --features "full"
@echo "$(GREEN)✓ Unit tests passed$(NC)"
.PHONY: test-tester
test-tester:
@echo "$(BLUE)Running mcp-tester's own tests...$(NC)"
@out=$$(RUST_LOG=$(RUST_LOG) RUST_BACKTRACE=$(RUST_BACKTRACE) $(CARGO) test -p mcp-tester 2>&1); \
status=$$?; \
echo "$$out"; \
if [ $$status -ne 0 ]; then exit $$status; fi; \
ran=$$(echo "$$out" | awk '/^test result:/ { total += $$4 } END { print total+0 }'); \
if [ "$$ran" -eq 0 ]; then \
echo "$(RED)✗ mcp-tester reported 0 tests — the gate is not reaching this crate$(NC)"; \
exit 1; \
fi; \
echo "$(GREEN)✓ mcp-tester tests passed ($$ran tests)$(NC)"
.PHONY: test-cargo-pmcp
test-cargo-pmcp:
@echo "$(BLUE)Running cargo-pmcp's own tests...$(NC)"
@out=$$(RUSTFLAGS= RUST_LOG=$(RUST_LOG) RUST_BACKTRACE=$(RUST_BACKTRACE) $(CARGO) test -p cargo-pmcp --lib 2>&1; \
RUSTFLAGS= RUST_LOG=$(RUST_LOG) RUST_BACKTRACE=$(RUST_BACKTRACE) $(CARGO) test -p cargo-pmcp --bins -- --test-threads=1 2>&1); \
status=$$?; \
echo "$$out"; \
if [ $$status -ne 0 ]; then exit $$status; fi; \
ran=$$(echo "$$out" | awk '/^test result:/ { total += $$4 } END { print total+0 }'); \
if [ "$$ran" -eq 0 ]; then \
echo "$(RED)✗ cargo-pmcp reported 0 tests — the gate is not reaching this crate$(NC)"; \
exit 1; \
fi; \
for t in src/lib.rs src/main.rs; do \
n=$$(printf '%s\n' "$$out" | awk -v want="$$t" -f scripts/named-test-binary-count.awk); \
case "$$n" in \
-1) \
echo "$(RED)✗ unittest target '$$t' never RAN. If a --lib/--bins selector was dropped from this recipe that is the cause — it is exactly how 927 bin-target tests went dark while this leg reported green.$(NC)"; \
exit 1;; \
-2) \
echo "$(RED)✗ unittest target '$$t' printed a target line but NO 'test result:' followed — truncated output. This gate refuses to pass on output it cannot read.$(NC)"; \
exit 1;; \
0) \
echo "$(RED)✗ unittest target '$$t' RAN but passed ZERO tests. The summed total ($$ran) stays nonzero from the other target, so the count guard above CANNOT catch this.$(NC)"; \
exit 1;; \
''|*[!0-9]*) \
echo "$(RED)✗ unittest target '$$t' — extractor gave no usable reading ('$$n'). EMPTY means awk did not run: check scripts/named-test-binary-count.awk.$(NC)"; \
exit 1;; \
esac; \
echo "$(GREEN) ✓ $$t ran ($$n passed)$(NC)"; \
done; \
echo "$(GREEN)✓ cargo-pmcp tests passed ($$ran tests)$(NC)"
.PHONY: test-cargo-pmcp-integration
test-cargo-pmcp-integration: test-openapi-server-guard-selftest
@echo "$(BLUE)Running cargo-pmcp's contract/inspect integration tests...$(NC)"
@out=$$(RUSTFLAGS= RUST_LOG=$(RUST_LOG) RUST_BACKTRACE=$(RUST_BACKTRACE) $(CARGO) test -p cargo-pmcp --test package_capture_contract --test package_attestation_contract --test package_inspect --test pmcp_package_pin --test package_save_load --test package_portability_contract --test package_artifact_framing --test verb_help -- --test-threads=1 2>&1); \
status=$$?; \
echo "$$out"; \
if [ $$status -ne 0 ]; then exit $$status; fi; \
ran=$$(echo "$$out" | awk '/^test result:/ { total += $$4 } END { print total+0 }'); \
if [ "$$ran" -eq 0 ]; then \
echo "$(RED)✗ cargo-pmcp integration tests reported 0 tests — the gate is not reaching cargo-pmcp/tests/$(NC)"; \
exit 1; \
fi; \
REQUIRED_TEST_BINARIES="package_capture_contract package_attestation_contract package_inspect pmcp_package_pin package_save_load package_portability_contract package_artifact_framing verb_help"; \
for b in $$REQUIRED_TEST_BINARIES; do \
n=$$(printf '%s\n' "$$out" | awk -v want="tests/$$b.rs" -f scripts/named-test-binary-count.awk); \
case "$$n" in \
-1) \
echo "$(RED)✗ required test binary '$$b' never RAN — cargo printed no 'Running tests/$$b.rs' target line. Likeliest causes: the file was renamed, or that tests/ entry stopped being a target.$(NC)"; \
exit 1;; \
-2) \
echo "$(RED)✗ required test binary '$$b' printed a target line but NO 'test result:' line followed it — truncated output or an aborted harness. This gate refuses to pass on output it cannot read.$(NC)"; \
exit 1;; \
0) \
echo "$(RED)✗ required test binary '$$b' RAN but passed ZERO tests. A exit 1;; \
''|*[!0-9]*) \
echo "$(RED)✗ required test binary '$$b' — the count extractor produced no usable reading ('$$n'). An EMPTY value means awk itself did not run: check that scripts/named-test-binary-count.awk exists and is readable. Failing rather than continuing on a reading this gate does not understand.$(NC)"; \
exit 1;; \
*) \
echo "$(GREEN) ✓ $$b passed $$n tests$(NC)";; \
esac; \
done; \
echo "$(GREEN)✓ cargo-pmcp integration tests passed ($$ran tests)$(NC)"
.PHONY: test-server-toolkit
test-server-toolkit:
@echo "$(BLUE)Running pmcp-server-toolkit's own tests...$(NC)"
@out=$$(RUST_LOG=$(RUST_LOG) RUST_BACKTRACE=$(RUST_BACKTRACE) $(CARGO) test -p pmcp-server-toolkit --features http -- --test-threads=1 2>&1); \
status=$$?; \
echo "$$out"; \
if [ $$status -ne 0 ]; then exit $$status; fi; \
ran=$$(echo "$$out" | awk '/^test result:/ { total += $$4 } END { print total+0 }'); \
if [ "$$ran" -eq 0 ]; then \
echo "$(RED)✗ pmcp-server-toolkit reported 0 tests — the gate is not reaching this crate$(NC)"; \
exit 1; \
fi; \
REQUIRED_TEST_BINARIES="env_ref_grammar_parity base_url_expansion"; \
for b in $$REQUIRED_TEST_BINARIES; do \
n=$$(printf '%s\n' "$$out" | awk -v want="tests/$$b.rs" -f scripts/named-test-binary-count.awk); \
case "$$n" in \
-1) \
echo "$(RED)✗ required test binary '$$b' never RAN — cargo printed no 'Running tests/$$b.rs' target line.$(NC)"; \
exit 1;; \
-2) \
echo "$(RED)✗ required test binary '$$b' printed a target line but NO 'test result:' line followed it.$(NC)"; \
exit 1;; \
0) \
echo "$(RED)✗ required test binary '$$b' RAN but passed ZERO tests — a exit 1;; \
''|*[!0-9]*) \
echo "$(RED)✗ required test binary '$$b' — the count extractor produced no usable reading ('$$n').$(NC)"; \
exit 1;; \
*) \
echo "$(GREEN) ✓ $$b passed $$n tests$(NC)";; \
esac; \
done; \
echo "$(GREEN)✓ pmcp-server-toolkit tests passed ($$ran tests)$(NC)"
.PHONY: test-openapi-server-guard-selftest
test-openapi-server-guard-selftest:
@echo "$(BLUE)Self-testing the named-test-binary count extractor...$(NC)"
@fail=0; ran=0; \
WANT=tests/roundtrip_e2e.rs; \
RUN=" Running $$WANT (target/debug/deps/roundtrip_e2e-a4768583f5fb6f6b)"; \
ESC=$$(printf '\033'); \
RUN_COLORED="$${ESC}[1m$${ESC}[92m Running$${ESC}[0m $$WANT (target/debug/deps/roundtrip_e2e-a4768583f5fb6f6b)"; \
check() { \
fixture="$$1"; expected="$$2"; shift 2; \
actual=$$(printf '%s\n' "$$@" | awk -v want="$$WANT" -f scripts/named-test-binary-count.awk); \
ran=$$((ran + 1)); \
if [ "$$actual" != "$$expected" ]; then \
echo "$(RED)✗ guard self-test fixture '$$fixture': expected $$expected, actual $$actual$(NC)"; \
fail=1; \
fi; \
}; \
check real 8 "$$RUN" '' 'running 8 tests' '' \
'test result: ok. 8 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.75s'; \
check all_ignored 0 "$$RUN" '' 'running 1 test' 'test roundtrip_smoke ... ignored' '' \
'test result: ok. 0 passed; 0 failed; 1 ignored; 0 measured; 0 filtered out; finished in 0.00s'; \
check cfg_empty 0 "$$RUN" '' 'running 0 tests' '' \
'test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s'; \
check diagnostic_only -1 'warning: unused import: std::env' " --> $$WANT:123:5" \
' Running unittests src/lib.rs (target/debug/deps/pmcp_openapi_server-2f0a1c9d4b6e8a13)' \
'' 'running 14 tests' '' \
'test result: ok. 14 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.05s'; \
check truncated -2 "$$RUN" '' 'running 8 tests'; \
check colorized 8 "$$RUN_COLORED" '' 'running 8 tests' '' \
'test result: ok. 8 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.75s'; \
if [ "$$fail" -ne 0 ]; then exit 1; fi; \
if [ "$$ran" -ne 6 ]; then \
echo "$(RED)✗ count extractor self-test executed $$ran fixtures, expected 6 — a fixture was lost$(NC)"; \
exit 1; \
fi; \
echo "$(GREEN)✓ count extractor self-test passed ($$ran fixtures)$(NC)"
.PHONY: test-openapi-server
test-openapi-server: test-openapi-server-guard-selftest
@echo "$(BLUE)Running pmcp-openapi-server's own tests...$(NC)"
@out=$$(RUST_LOG=$(RUST_LOG) RUST_BACKTRACE=$(RUST_BACKTRACE) $(CARGO) test -p pmcp-openapi-server -- --test-threads=1 2>&1); \
status=$$?; \
echo "$$out"; \
if [ $$status -ne 0 ]; then exit $$status; fi; \
ran=$$(echo "$$out" | awk '/^test result:/ { total += $$4 } END { print total+0 }'); \
if [ "$$ran" -eq 0 ]; then \
echo "$(RED)✗ pmcp-openapi-server reported 0 tests — the gate is not reaching this crate$(NC)"; \
exit 1; \
fi; \
REQUIRED_TEST_BINARIES="parity_replay pmcp_package_pin roundtrip_e2e"; \
for b in $$REQUIRED_TEST_BINARIES; do \
n=$$(printf '%s\n' "$$out" | awk -v want="tests/$$b.rs" -f scripts/named-test-binary-count.awk); \
case "$$n" in \
-1) \
echo "$(RED)✗ required test binary '$$b' never RAN — cargo printed no 'Running tests/$$b.rs' target line. Likeliest causes: the file was renamed, or that tests/ entry stopped being a target.$(NC)"; \
exit 1;; \
-2) \
echo "$(RED)✗ required test binary '$$b' printed a target line but NO 'test result:' line followed it — truncated output or an aborted harness. This gate refuses to pass on output it cannot read.$(NC)"; \
exit 1;; \
0) \
echo "$(RED)✗ required test binary '$$b' RAN but passed ZERO tests. A exit 1;; \
''|*[!0-9]*) \
echo "$(RED)✗ required test binary '$$b' — the count extractor produced no usable reading ('$$n'). An EMPTY value means awk itself did not run: check that scripts/named-test-binary-count.awk exists and is readable. Failing rather than continuing on a reading this gate does not understand.$(NC)"; \
exit 1;; \
*) \
echo "$(GREEN) ✓ $$b passed $$n tests$(NC)";; \
esac; \
done; \
echo "$(GREEN)✓ pmcp-openapi-server tests passed ($$ran tests)$(NC)"
.PHONY: test-doc
test-doc:
@echo "$(BLUE)Running doctests...$(NC)"
RUSTFLAGS="$(RUSTFLAGS)" $(CARGO) test --doc --features "full"
@echo "$(GREEN)✓ All doctests passed$(NC)"
.PHONY: test-property
test-property:
@echo "$(BLUE)Running property tests (ALWAYS required for new features)...$(NC)"
PROPTEST_CASES=1000 RUST_LOG=$(RUST_LOG) $(CARGO) test --features "full" -- --ignored property_
@echo "$(GREEN)✓ Property tests passed$(NC)"
.PHONY: test-fuzz
test-fuzz:
@echo "$(BLUE)Running fuzz tests (ALWAYS required for new features)...$(NC)"
@if [ -d "fuzz" ]; then \
cd fuzz && $(CARGO) fuzz list | while read target; do \
echo "$(BLUE)Fuzzing $$target...$(NC)"; \
timeout 30s $(CARGO) fuzz run $$target || echo "$(YELLOW)Fuzz target $$target completed$(NC)"; \
done; \
else \
echo "$(YELLOW)⚠ No fuzz directory found. Run 'cargo fuzz init' to create fuzz tests$(NC)"; \
fi
@echo "$(GREEN)✓ Fuzz testing completed$(NC)"
.PHONY: build-cargo-pmcp-examples
build-cargo-pmcp-examples:
@echo "$(BLUE)Building cargo-pmcp's examples...$(NC)"
@RUSTFLAGS= $(CARGO) build -p cargo-pmcp --examples
@echo "$(GREEN)✓ cargo-pmcp examples built$(NC)"
.PHONY: test-examples
test-examples: build-cargo-pmcp-examples
./scripts/run-example-builds.sh
.PHONY: build-tester
build-tester:
@echo "$(BLUE)MCP tester build skipped - using external tester$(NC)"
@echo "$(GREEN)✓ Ready for testing$(NC)"
.PHONY: test-with-tester
test-with-tester: build-tester
@echo "$(BLUE)Running MCP tester against example servers...$(NC)"
@chmod +x scripts/test_examples_with_tester.sh
@./scripts/test_examples_with_tester.sh || true
@echo "$(GREEN)✓ MCP tester validation completed$(NC)"
.PHONY: test-example-server
test-example-server: build-tester
@echo "$(BLUE)Testing specific example server: $(EXAMPLE)$(NC)"
@if [ -z "$(EXAMPLE)" ]; then \
echo "$(RED)Error: EXAMPLE not specified. Use: make test-example-server EXAMPLE=t04_streamable_http_stateful$(NC)"; \
exit 1; \
fi
@chmod +x scripts/test_examples_with_tester.sh
@./scripts/test_examples_with_tester.sh $(EXAMPLE)
.PHONY: generate-test-scenario
generate-test-scenario: build-tester
@echo "$(BLUE)Generating test scenario for server at $(URL)...$(NC)"
@if [ -z "$(URL)" ]; then \
echo "$(RED)Error: URL not specified. Use: make generate-test-scenario URL=http://localhost:8080$(NC)"; \
exit 1; \
fi
./target/release/mcp-tester generate-scenario $(URL) -o generated_scenario.yaml --all-tools
@echo "$(GREEN)✓ Test scenario generated at generated_scenario.yaml$(NC)"
.PHONY: test-integration
test-integration:
@echo "$(BLUE)Running integration tests...$(NC)"
RUST_LOG=$(RUST_LOG) RUST_BACKTRACE=$(RUST_BACKTRACE) $(CARGO) test --test '*' --features "full"
@echo "$(GREEN)✓ Integration tests passed$(NC)"
.PHONY: test-severance
test-severance:
@echo "$(BLUE)Running v1-severance proofs on --features full-v2...$(NC)"
./scripts/run-severance-proofs.sh
@echo "$(GREEN)✓ Severance proofs ran with non-zero test counts$(NC)"
.PHONY: lint-plans
lint-plans:
@echo "$(BLUE)Linting GSD plan verification commands (D-19)...$(NC)"
./scripts/lint-plan-verify-commands.sh
@echo "$(GREEN)✓ No verification command masks the status of what it verifies$(NC)"
.PHONY: release-sweep
release-sweep:
@echo "$(BLUE)Sweeping release version drift against crates.io (D-05)...$(NC)"
./scripts/release-version-sweep.sh
@echo "$(GREEN)✓ Every publishable crate measured against the registry$(NC)"
.PHONY: check-release-coverage-guard-selftest
check-release-coverage-guard-selftest:
@echo "$(BLUE)Self-testing the release-ledger coverage gate (red direction)...$(NC)"
@fail=0; ran=0; \
SRC=.github/workflows/release.yml; \
tmp=$$(mktemp -d); \
trap 'rm -rf "$$tmp"' EXIT; \
doctored_ok() { \
fixture="$$1"; expected="$$2"; doctored="$$3"; \
before_lines=$$(wc -l < "$$SRC"); \
after_lines=$$(wc -l < "$$doctored"); \
d=$$((before_lines - after_lines)); \
if [ "$$d" -ne "$$expected" ]; then \
echo "$(RED)✗ coverage gate self-test fixture '$$fixture': doctoring changed the line count by $$d, expected $$expected — the fixture does not doctor what it claims$(NC)"; \
fail=1; \
fi; \
if cmp -s "$$SRC" "$$doctored"; then \
echo "$(RED)✗ coverage gate self-test fixture '$$fixture': the doctored copy is BYTE-IDENTICAL to the source — this fixture proves nothing$(NC)"; \
fail=1; \
fi; \
}; \
check() { \
fixture="$$1"; expected="$$2"; doctored="$$3"; needle="$$4"; cdir="$$5"; \
ran=$$((ran + 1)); \
actual=0; \
CRATES_DIR="$$cdir" ./scripts/check-release-coverage.sh "$$doctored" >"$$tmp/out" 2>&1 || actual=$$?; \
if [ "$$expected" = "0" ] && [ "$$actual" -ne 0 ]; then \
echo "$(RED)✗ coverage gate self-test fixture '$$fixture': expected exit 0, got $$actual$(NC)"; \
cat "$$tmp/out"; fail=1; return 0; \
fi; \
if [ "$$expected" != "0" ] && [ "$$actual" -eq 0 ]; then \
echo "$(RED)✗ coverage gate self-test fixture '$$fixture': expected NON-ZERO exit, got 0 — the gate passed input it must reject$(NC)"; \
cat "$$tmp/out"; fail=1; return 0; \
fi; \
if [ -n "$$needle" ] && ! grep -q "$$needle" "$$tmp/out"; then \
echo "$(RED)✗ coverage gate self-test fixture '$$fixture': failed for the wrong reason — output never names '$$needle'$(NC)"; \
cat "$$tmp/out"; fail=1; return 0; \
fi; \
return 0; \
}; \
PKG_STEP='cargo publish --manifest-path crates/pmcp-package/Cargo.toml'; \
cp "$$SRC" "$$tmp/intact.yml"; \
grep -v "$$PKG_STEP" "$$SRC" > "$$tmp/excluded_removed.yml"; \
doctored_ok excluded_step_removed 1 "$$tmp/excluded_removed.yml"; \
grep -v 'cargo publish -p pmcp-widget-utils' "$$SRC" > "$$tmp/root_removed.yml"; \
doctored_ok root_step_removed 1 "$$tmp/root_removed.yml"; \
sed 's|^\(.*'"$$PKG_STEP"'.*\)$$|#\1|' "$$SRC" > "$$tmp/excluded_commented.yml"; \
doctored_ok excluded_step_commented 0 "$$tmp/excluded_commented.yml"; \
grep -v "$$PKG_STEP" "$$SRC" > "$$tmp/order_inverted.yml"; \
grep "$$PKG_STEP" "$$SRC" >> "$$tmp/order_inverted.yml"; \
doctored_ok order_inverted 0 "$$tmp/order_inverted.yml"; \
sed 's|cargo publish -p pmcp-agent |cargo publish -p pmcp-agent-extra |' "$$SRC" > "$$tmp/prefix_shadow.yml"; \
doctored_ok prefix_shadow 0 "$$tmp/prefix_shadow.yml"; \
mkdir -p "$$tmp/crates/zz-synthetic/src"; \
: > "$$tmp/crates/zz-synthetic/src/lib.rs"; \
printf '%s\n' '[workspace]' '' '[package]' 'name = "zz-synthetic-uncovered"' 'version = "0.0.0"' 'edition = "2021"' > "$$tmp/crates/zz-synthetic/Cargo.toml"; \
check intact 0 "$$tmp/intact.yml" '' ''; \
check excluded_step_removed nonzero "$$tmp/excluded_removed.yml" 'pmcp-package' ''; \
check root_step_removed nonzero "$$tmp/root_removed.yml" 'pmcp-widget-utils' ''; \
check excluded_step_commented nonzero "$$tmp/excluded_commented.yml" 'pmcp-package' ''; \
check order_inverted nonzero "$$tmp/order_inverted.yml" 'pmcp-package' ''; \
check workflow_absent nonzero "$$tmp/does-not-exist.yml" '' ''; \
check synthetic_excluded_uncovered nonzero "$$tmp/intact.yml" 'zz-synthetic-uncovered' "$$tmp/crates"; \
check prefix_shadow nonzero "$$tmp/prefix_shadow.yml" 'pmcp-agent' ''; \
if [ "$$fail" -ne 0 ]; then exit 1; fi; \
if [ "$$ran" -ne 8 ]; then \
echo "$(RED)✗ coverage gate self-test executed $$ran fixtures, expected 8 — a fixture was lost$(NC)"; \
exit 1; \
fi; \
echo "$(GREEN)✓ release-coverage gate self-test passed ($$ran fixtures)$(NC)"
.PHONY: check-release-coverage
check-release-coverage: check-release-coverage-guard-selftest
@echo "$(BLUE)Checking release-ledger coverage...$(NC)"
./scripts/check-release-coverage.sh
@echo "$(GREEN)✓ Every publishable workspace member has a publish step$(NC)"
.PHONY: test-conformance
test-conformance:
@echo "$(BLUE)Running the official MCP conformance suite (both revisions, one process)...$(NC)"
./scripts/run-conformance-suite.sh
@echo "$(GREEN)✓ CONF-01 gates passed (MRTR surface green, check floors met, zero-check sets exact)$(NC)"
.PHONY: test-era-matrix
test-era-matrix:
@echo "$(BLUE)Running the era matrix on a dev-dependency-free build...$(NC)"
./scripts/run-era-matrix.sh
@echo "$(GREEN)✓ CONF-02/CONF-03 targets ran with non-zero test counts$(NC)"
.PHONY: test-feature-flags
test-feature-flags:
@echo "$(BLUE)Verifying feature flag combinations for pmcp-tasks...$(NC)"
@echo "$(YELLOW)1/4: No features (InMemory only)...$(NC)"
$(CARGO) check -p pmcp-tasks --no-default-features
$(CARGO) clippy -p pmcp-tasks --no-default-features -- -D warnings
$(CARGO) test -p pmcp-tasks --no-default-features --no-run
$(CARGO) test -p pmcp-tasks --no-default-features --doc
RUSTDOCFLAGS="-D warnings" $(CARGO) doc -p pmcp-tasks --no-default-features --no-deps
@echo "$(GREEN)✓ 1/4 passed: no features$(NC)"
@echo "$(YELLOW)2/4: dynamodb only...$(NC)"
$(CARGO) check -p pmcp-tasks --features dynamodb
$(CARGO) clippy -p pmcp-tasks --features dynamodb -- -D warnings
$(CARGO) test -p pmcp-tasks --features dynamodb --no-run
$(CARGO) test -p pmcp-tasks --features dynamodb --doc
RUSTDOCFLAGS="-D warnings" $(CARGO) doc -p pmcp-tasks --features dynamodb --no-deps
@echo "$(GREEN)✓ 2/4 passed: dynamodb$(NC)"
@echo "$(YELLOW)3/4: redis only...$(NC)"
$(CARGO) check -p pmcp-tasks --features redis
$(CARGO) clippy -p pmcp-tasks --features redis -- -D warnings
$(CARGO) test -p pmcp-tasks --features redis --no-run
$(CARGO) test -p pmcp-tasks --features redis --doc
RUSTDOCFLAGS="-D warnings" $(CARGO) doc -p pmcp-tasks --features redis --no-deps
@echo "$(GREEN)✓ 3/4 passed: redis$(NC)"
@echo "$(YELLOW)4/4: dynamodb + redis...$(NC)"
$(CARGO) check -p pmcp-tasks --features "dynamodb,redis"
$(CARGO) clippy -p pmcp-tasks --features "dynamodb,redis" -- -D warnings
$(CARGO) test -p pmcp-tasks --features "dynamodb,redis" --no-run
$(CARGO) test -p pmcp-tasks --features "dynamodb,redis" --doc
RUSTDOCFLAGS="-D warnings" $(CARGO) doc -p pmcp-tasks --features "dynamodb,redis" --no-deps
@echo "$(GREEN)✓ 4/4 passed: dynamodb + redis$(NC)"
@echo "$(GREEN)═══════════════════════════════════════════════════════$(NC)"
@echo "$(GREEN) All 4 feature flag combinations verified for pmcp-tasks$(NC)"
@echo "$(GREEN)═══════════════════════════════════════════════════════$(NC)"
.PHONY: test-playwright-setup
test-playwright-setup:
@echo "$(BLUE)Setting up Playwright for widget testing...$(NC)"
@cd tests/playwright && npm install && npm run install:browsers
@echo "$(GREEN)✓ Playwright setup complete$(NC)"
.PHONY: test-playwright
test-playwright:
@echo "$(BLUE)Running Playwright widget tests...$(NC)"
@cd tests/playwright && npm test
@echo "$(GREEN)✓ Playwright widget tests passed$(NC)"
.PHONY: test-playwright-headed
test-playwright-headed:
@echo "$(BLUE)Running Playwright widget tests (headed mode)...$(NC)"
@cd tests/playwright && npm run test:headed
.PHONY: test-playwright-ui
test-playwright-ui:
@echo "$(BLUE)Running Playwright UI mode...$(NC)"
@cd tests/playwright && npm run test:ui
.PHONY: test-all
test-all: test-unit test-doc test-property test-examples test-integration test-tester test-cargo-pmcp test-cargo-pmcp-integration test-server-toolkit test-openapi-server
@echo "$(GREEN)✓ All test suites passed (ALWAYS requirements met)$(NC)"
.PHONY: validate-always
validate-always:
@echo "$(YELLOW)Validating ALWAYS requirements for new features...$(NC)"
@echo "$(BLUE)1. FUZZ Testing validation...$(NC)"
@$(MAKE) test-fuzz
@echo "$(BLUE)2. PROPERTY Testing validation...$(NC)"
@$(MAKE) test-property
@echo "$(BLUE)3. UNIT Testing validation...$(NC)"
@$(MAKE) test-unit
@echo "$(BLUE)4. EXAMPLE demonstration validation...$(NC)"
@$(MAKE) test-examples
@echo "$(GREEN)✅ ALL ALWAYS requirements validated!$(NC)"
.PHONY: coverage
coverage:
@echo "$(BLUE)Running coverage analysis...$(NC)"
$(CARGO) llvm-cov --all-features --package pmcp --lcov --output-path lcov.info
@echo "$(BLUE)Calculating coverage percentage...$(NC)"
@TOTAL_LINES=$$(grep "^LF:" lcov.info | awk -F: '{sum+=$$2} END {print sum}'); \
HIT_LINES=$$(grep "^LH:" lcov.info | awk -F: '{sum+=$$2} END {print sum}'); \
PERCENTAGE=$$(echo "scale=2; $$HIT_LINES / $$TOTAL_LINES * 100" | bc); \
echo "$(GREEN)✓ Coverage: $$PERCENTAGE% ($$HIT_LINES/$$TOTAL_LINES lines)$(NC)"
.PHONY: coverage-ci
coverage-ci:
@echo "$(BLUE)Running CI coverage...$(NC)"
$(CARGO) llvm-cov --all-features --package pmcp --lcov --output-path lcov.info
@TOTAL_LINES=$$(grep "^LF:" lcov.info | awk -F: '{sum+=$$2} END {print sum}'); \
HIT_LINES=$$(grep "^LH:" lcov.info | awk -F: '{sum+=$$2} END {print sum}'); \
PERCENTAGE=$$(echo "scale=2; $$HIT_LINES / $$TOTAL_LINES * 100" | bc); \
echo "Coverage: $$PERCENTAGE% ($$HIT_LINES/$$TOTAL_LINES lines)"
.PHONY: bench
bench:
@echo "$(BLUE)Running benchmarks...$(NC)"
$(CARGO) bench --all-features
@echo "$(GREEN)✓ Benchmarks complete$(NC)"
.PHONY: doc
doc:
@echo "$(BLUE)Building API documentation...$(NC)"
RUSTDOCFLAGS="--cfg docsrs" $(CARGO) doc --all-features --no-deps
@echo "$(GREEN)✓ API documentation built$(NC)"
.PHONY: doc-open
doc-open: doc
@echo "$(BLUE)Opening API documentation...$(NC)"
$(CARGO) doc --all-features --no-deps --open
.PHONY: doc-check
doc-check:
@echo "$(BLUE)Checking rustdoc warnings (zero-tolerance)...$(NC)"
RUSTDOCFLAGS="-D warnings" $(CARGO) doc --no-deps \
--features composition,http,http-client,jwt-auth,macros,mcp-apps,oauth,rayon,resource-watcher,schema-generation,simd,sse,streamable-http,validation,websocket,v1-compat
@echo "$(GREEN)✓ Zero rustdoc warnings$(NC)"
.PHONY: book
book:
@echo "$(BLUE)Building PMCP book...$(NC)"
@if ! command -v mdbook &> /dev/null; then \
echo "$(YELLOW)Installing mdBook...$(NC)"; \
$(CARGO) install mdbook; \
fi
cd pmcp-book && mdbook build
@echo "$(GREEN)✓ PMCP book built$(NC)"
.PHONY: book-open
book-open: book
@echo "$(BLUE)Opening PMCP book...$(NC)"
cd pmcp-book && mdbook serve --open
.PHONY: book-serve
book-serve:
@echo "$(BLUE)Serving PMCP book...$(NC)"
@if ! command -v mdbook &> /dev/null; then \
echo "$(YELLOW)Installing mdBook...$(NC)"; \
$(CARGO) install mdbook; \
fi
cd pmcp-book && mdbook serve
.PHONY: book-test
book-test:
@echo "$(BLUE)Testing PMCP book examples...$(NC)"
cd pmcp-book && mdbook test
@echo "$(GREEN)✓ Book examples tested$(NC)"
.PHONY: book-clean
book-clean:
@echo "$(BLUE)Cleaning book build artifacts...$(NC)"
rm -rf pmcp-book/book/
@echo "$(GREEN)✓ Book cleaned$(NC)"
.PHONY: docs-all
docs-all: doc book
@echo "$(GREEN)✓ All documentation built$(NC)"
PURITY_CRATES := pmcp-workbook-runtime pmcp-workbook-dialect
PURITY_WRITER_CRATES := pmcp-workbook-runtime
.PHONY: purity-check
purity-check:
@ @ @ @ @ @ @ @cargo metadata --format-version 1 >/dev/null 2>&1 || { echo "purity-check FAILED: could not resolve Cargo.lock (failing closed)"; exit 1; }
@echo "$(BLUE)purity-check: Phase 91 reader-free boundary gate (fail-closed, per-crate/per-feature)$(NC)"
@set -euo pipefail; \
BAN='umya|calamine|quick-xml|swc_|pmcp-code-mode'; \
for crate in $(PURITY_CRATES); do \
for feat in "" "--no-default-features" "--all-features"; do \
status=0; tree=$$(cargo tree -p $$crate $$feat 2>&1) || status=$$?; \
if [ $$status -ne 0 ]; then \
echo "purity-check FAILED: cargo tree errored for $$crate ($$feat) [exit $$status] — failing closed"; \
printf '%s\n' "$$tree"; \
exit 1; \
fi; \
if printf '%s\n' "$$tree" | grep -Ei "$$BAN"; then \
echo "purity-check FAILED: reader/JS dep in $$crate ($$feat) — the served boundary is breached"; \
exit 1; \
fi; \
if echo " $(PURITY_WRITER_CRATES) " | grep -q " $$crate " && \
! printf '%s\n' "$$tree" | grep -qi 'rust_xlsxwriter'; then \
echo "purity-check FAILED: rust_xlsxwriter ABSENT from $$crate tree ($$feat) — the writer/renderer is missing (non-vacuous positive assertion)"; \
exit 1; \
fi; \
done; \
done; \
echo "purity-check: Layer 1 clean — no umya/calamine/quick-xml/swc_/pmcp-code-mode in $(PURITY_CRATES) (all feature combos); rust_xlsxwriter present in $(PURITY_WRITER_CRATES) (zip permitted via the writer)"
@ @ @ @ @ @ @ @ @echo "$(BLUE)purity-check: Phase 92 — pmcp-server-toolkit workbook[-embedded] reader-absence (distinct from PURITY_CRATES)$(NC)"
@set -euo pipefail; \
BAN='umya|calamine|quick-xml|swc_|pmcp-code-mode'; \
for feat in "workbook" "workbook-embedded"; do \
status=0; tree=$$(cargo tree -p pmcp-server-toolkit --no-default-features --features "$$feat" 2>&1) || status=$$?; \
if [ $$status -ne 0 ]; then \
echo "purity-check FAILED: cargo tree errored for pmcp-server-toolkit (--features $$feat) [exit $$status] — failing closed"; \
printf '%s\n' "$$tree"; \
exit 1; \
fi; \
if printf '%s\n' "$$tree" | grep -Ei "$$BAN"; then \
echo "purity-check FAILED: reader/JS dep in pmcp-server-toolkit (--features $$feat) — the served workbook boundary is breached"; \
exit 1; \
fi; \
done; \
echo "purity-check: pmcp-server-toolkit workbook + workbook-embedded are reader-free (umya/calamine/quick-xml/swc_/pmcp-code-mode absent in BOTH; include_dir permitted in the embedded tree)"
@ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @echo "$(BLUE)purity-check: Phase 93 — pmcp-workbook-compiler reader-present (positive) + single-version guard$(NC)"
@set -euo pipefail; \
status=0; umya=$$(cargo tree -p pmcp-workbook-compiler -i umya-spreadsheet 2>&1) || status=$$?; \
if [ $$status -ne 0 ]; then \
echo "purity-check FAILED: cargo tree -i umya-spreadsheet errored for pmcp-workbook-compiler [exit $$status] — failing closed"; \
printf '%s\n' "$$umya"; exit 1; \
fi; \
if ! printf '%s\n' "$$umya" | grep -qE '^umya-spreadsheet v'; then \
echo "purity-check FAILED: umya-spreadsheet ABSENT from pmcp-workbook-compiler tree — the reader is missing (non-vacuous positive assertion)"; \
exit 1; \
fi; \
status=0; qx=$$(cargo tree -p pmcp-workbook-compiler -i quick-xml 2>&1) || status=$$?; \
if [ $$status -ne 0 ]; then \
echo "purity-check FAILED: cargo tree -i quick-xml errored for pmcp-workbook-compiler [exit $$status] — failing closed"; \
printf '%s\n' "$$qx"; exit 1; \
fi; \
qxn=$$(printf '%s\n' "$$qx" | grep -cE '^quick-xml v'); \
if [ "$$qxn" -ne 1 ]; then \
echo "purity-check FAILED: pmcp-workbook-compiler resolves $$qxn quick-xml versions (expected exactly 1 — a forked second copy breaches the single-version guard)"; \
printf '%s\n' "$$qx"; exit 1; \
fi; \
zipn=$$(cargo tree -p pmcp-workbook-compiler -e no-dev 2>&1 | grep -cE 'umya-spreadsheet v3' || true); \
zipv=$$(cargo tree -p pmcp-workbook-compiler 2>&1 | grep -oE 'zip v[0-9]+\.[0-9]+\.[0-9]+' | sort -u); \
zipuniq=$$(printf '%s\n' "$$zipv" | grep -c 'zip v'); \
if [ "$$zipuniq" -gt 2 ]; then \
echo "purity-check FAILED: pmcp-workbook-compiler tree holds >2 zip versions ($$zipuniq) — only the writer (zip7) + umya reader (zip8) are expected; a forked third copy breaches the guard"; \
printf '%s\n' "$$zipv"; exit 1; \
fi; \
echo "purity-check: pmcp-workbook-compiler reader-present (umya-spreadsheet found), single quick-xml version, zip versions bounded to writer+reader ($$zipuniq) — reader confined to the compiler"
@ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @echo "$(BLUE)purity-check: Phase 95 — pmcp-workbook-server served cone reader-absence (distinct from PURITY_CRATES)$(NC)"
@set -euo pipefail; \
BAN='umya|calamine|quick-xml|swc_|pmcp-code-mode'; \
status=0; tree=$$(cargo tree -p pmcp-workbook-server 2>&1) || status=$$?; \
if [ $$status -ne 0 ]; then \
echo "purity-check FAILED: cargo tree errored for pmcp-workbook-server [exit $$status] — failing closed"; \
printf '%s\n' "$$tree"; \
exit 1; \
fi; \
if printf '%s\n' "$$tree" | grep -Ei "$$BAN"; then \
echo "purity-check FAILED: reader/JS dep in pmcp-workbook-server — the served binary boundary is breached"; \
exit 1; \
fi; \
echo "purity-check: pmcp-workbook-server reader-free (umya/calamine/quick-xml/swc_/pmcp-code-mode absent in the served binary tree)"
@echo "$(BLUE)purity-check: Layer 2 — crate-local cargo-deny [bans] (--manifest-path scoped; workspace deny.toml untouched)$(NC)"
@ @ @ @ @ @ @set -euo pipefail; \
ref=""; refcrate=""; \
for crate in $(PURITY_CRATES); do \
test -f crates/$$crate/deny.toml || { echo "purity-check FAILED: crates/$$crate/deny.toml missing — Layer 2 would be vacuous; failing closed"; exit 1; }; \
bans=$$(grep -E '\{ name = ' crates/$$crate/deny.toml | sort); \
if [ -z "$$refcrate" ]; then ref="$$bans"; refcrate=$$crate; \
elif [ "$$bans" != "$$ref" ]; then \
echo "purity-check FAILED: crates/$$crate/deny.toml [bans] deny list drifted from crates/$$refcrate/deny.toml — Layer 2 ban lists must stay in lockstep"; \
exit 1; \
fi; \
done; \
for crate in $(PURITY_CRATES); do \
cargo deny --manifest-path crates/$$crate/Cargo.toml check --config deny.toml bans; \
done
@echo "$(GREEN)purity-check PASSED: reader-free (umya/calamine/quick-xml/swc_/pmcp-code-mode absent) + writer-present (rust_xlsxwriter, per-feature) + zip-permitted + cargo-deny-bans-clean$(NC)"
PURITY_NO_CRYPTO_CRATES := pmcp-package
.PHONY: no-crypto-allowlist-guard-selftest
no-crypto-allowlist-guard-selftest:
@echo "$(BLUE)Self-testing the [bans].allow entry counter...$(NC)"
@fail=0; ran=0; \
check() { \
fixture="$$1"; expected="$$2"; shift 2; \
actual=$$(printf '%s\n' "$$@" | awk -f scripts/deny-allow-entry-count.awk); \
ran=$$((ran + 1)); \
if [ "$$actual" != "$$expected" ]; then \
echo "$(RED)✗ allowlist guard self-test fixture '$$fixture': expected $$expected, actual $$actual$(NC)"; \
fail=1; \
fi; \
}; \
check empty_allow 0 '[bans]' 'multiple-versions = "allow"' 'allow = []'; \
check multiline 2 '[bans]' 'allow = [' ' { name = "sha2" },' ' { name = "digest" },' ']'; \
check single_line 1 '[bans]' 'allow = [ { name = "sha2" } ]'; \
check licenses_first 1 '[licenses]' 'allow = []' '[bans]' 'allow = [ { name = "sha2" } ]'; \
check licenses_after 1 '[bans]' 'allow = [ { name = "sha2" } ]' '[licenses]' 'allow = []'; \
check comment_decoy 0 '# the allow list holds { name = "sha2" } entries' '[bans]' 'multiple-versions = "allow"'; \
if [ "$$fail" -ne 0 ]; then exit 1; fi; \
if [ "$$ran" -ne 6 ]; then \
echo "$(RED)✗ allowlist guard self-test executed $$ran fixtures, expected 6 — a fixture was lost$(NC)"; \
exit 1; \
fi; \
echo "$(GREEN)✓ allowlist entry-counter self-test passed ($$ran fixtures)$(NC)"
.PHONY: no-crypto-check
no-crypto-check: no-crypto-allowlist-guard-selftest
@echo "$(BLUE)no-crypto-check: pmcp-package must never gain a signing/crypto-protocol dependency$(NC)"
@set -euo pipefail; \
for crate in $(PURITY_NO_CRYPTO_CRATES); do \
test -f crates/$$crate/deny.toml || { \
echo "$(RED)✗ no-crypto-check FAILED: crates/$$crate/deny.toml missing. cargo-deny 0.18.3 does NOT fail on a missing --config path — it WARNs, falls back to the default empty-ban config and reports 'bans ok' VACUOUSLY (the WR-02 hazard). A deleted or renamed config must fail this gate, not silently disable it.$(NC)"; \
exit 1; \
}; \
status=0; n=$$(awk -f scripts/deny-allow-entry-count.awk crates/$$crate/deny.toml 2>&1) || status=$$?; \
if [ $$status -ne 0 ]; then \
echo "$(RED)✗ no-crypto-check FAILED: the allowlist entry counter errored for crates/$$crate/deny.toml [exit $$status] — failing closed rather than trusting a reading it could not produce.$(NC)"; \
printf '%s\n' "$$n"; \
exit 1; \
fi; \
case "$$n" in \
''|*[!0-9]*) \
echo "$(RED)✗ no-crypto-check FAILED: the allowlist entry counter produced no usable reading ('$$n') for crates/$$crate/deny.toml. An EMPTY value means awk itself did not run: check that scripts/deny-allow-entry-count.awk exists and is readable. Failing rather than continuing on a reading this gate does not understand.$(NC)"; \
exit 1;; \
esac; \
if [ "$$n" -eq 0 ]; then \
echo "$(RED)✗ no-crypto-check FAILED: crates/$$crate/deny.toml has an EMPTY or ABSENT [bans].allow list (reading: 0). One of three things is true: there is no [bans] section, it has no allow array, or that array is empty. Any of them is fatal — cargo-deny reports success for an EMPTY allow list exactly as vacuously as for a missing config, and ONLY a NON-EMPTY allow makes this check deny-by-default. Restore the allowlist; do not relax this guard.$(NC)"; \
exit 1; \
fi; \
echo "$(GREEN) ✓ crates/$$crate/deny.toml [bans].allow holds $$n entries (deny-by-default is active)$(NC)"; \
cargo deny --manifest-path crates/$$crate/Cargo.toml check --config deny.toml bans; \
done
@echo "$(GREEN)✓ no-crypto-check PASSED: $(PURITY_NO_CRYPTO_CRATES) resolved graph is allowlisted (hashing admitted, signing absent)$(NC)"
.PHONY: pmcp-package-gate
pmcp-package-gate:
@echo "$(BLUE)🔍 pmcp-package standalone gate (workspace-excluded crate)$(NC)"
$(CARGO) fmt --manifest-path crates/pmcp-package/Cargo.toml --all -- --check
$(CARGO) clippy --manifest-path crates/pmcp-package/Cargo.toml --all-targets -- -D warnings
@out=$$($(CARGO) test --manifest-path crates/pmcp-package/Cargo.toml 2>&1); \
status=$$?; \
echo "$$out"; \
if [ $$status -ne 0 ]; then exit $$status; fi; \
ran=$$(echo "$$out" | awk '/^test result:/ { total += $$4 } END { print total+0 }'); \
if [ "$$ran" -eq 0 ]; then \
echo "$(RED)✗ pmcp-package reported 0 tests — the gate is not reaching this workspace-excluded crate$(NC)"; \
exit 1; \
fi; \
echo "$(GREEN)✓ pmcp-package tests passed ($$ran tests)$(NC)"
$(CARGO) run --manifest-path crates/pmcp-package/Cargo.toml --example attestation_carriage
$(CARGO) run --manifest-path crates/pmcp-package/Cargo.toml --example config_slot_gates
@echo "$(GREEN)✓ pmcp-package fmt/clippy/test/example OK$(NC)"
.PHONY: quality-gate
quality-gate:
@echo "$(YELLOW)═══════════════════════════════════════════════════════$(NC)"
@echo "$(YELLOW) PMCP SDK TOYOTA WAY QUALITY GATE $(NC)"
@echo "$(YELLOW) Zero Tolerance for Defects $(NC)"
@echo "$(YELLOW)═══════════════════════════════════════════════════════$(NC)"
@echo "$(BLUE)🏭 Jidoka: Stopping the line for quality verification$(NC)"
@$(MAKE) lint-plans
@$(MAKE) check-release-coverage
@$(MAKE) fmt-check
@$(MAKE) lint
@$(MAKE) doc-check
@$(MAKE) build
@$(MAKE) test-all
@$(MAKE) pmcp-package-gate
@$(MAKE) audit
@$(MAKE) unused-deps
@$(MAKE) check-todos
@$(MAKE) check-unwraps
@$(MAKE) validate-always
@$(MAKE) purity-check
@$(MAKE) no-crypto-check
@$(MAKE) comply
@echo "$(GREEN)═══════════════════════════════════════════════════════$(NC)"
@echo "$(GREEN) ✅ ALL TOYOTA WAY QUALITY CHECKS PASSED $(NC)"
@echo "$(GREEN) 🎯 ALWAYS Requirements Validated $(NC)"
@echo "$(GREEN)═══════════════════════════════════════════════════════$(NC)"
.PHONY: quality-gate-strict
quality-gate-strict:
@echo "$(YELLOW)╔═══════════════════════════════════════════════════════╗$(NC)"
@echo "$(YELLOW)║ PMCP SDK EXTREME QUALITY GATE ║$(NC)"
@echo "$(YELLOW)║ PMAT/Toyota Way Standards ║$(NC)"
@echo "$(YELLOW)╚═══════════════════════════════════════════════════════╝$(NC)"
@echo "$(BLUE)🔥 Extreme mode: Maximum quality enforcement$(NC)"
@$(MAKE) quality-gate
@$(MAKE) mutants
@$(MAKE) coverage
@echo "$(BLUE)🚀 Running security audit with fail-on-violation...$(NC)"
@$(CARGO) audit || (echo "$(RED)❌ Security vulnerabilities found!$(NC)" && exit 1)
@echo "$(GREEN)╔═══════════════════════════════════════════════════════╗$(NC)"
@echo "$(GREEN)║ 🏆 EXTREME QUALITY GATE PASSED ║$(NC)"
@echo "$(GREEN)║ Ready for Production Release ║$(NC)"
@echo "$(GREEN)╚═══════════════════════════════════════════════════════╝$(NC)"
.PHONY: pre-commit-gate
pre-commit-gate:
@echo "$(YELLOW)🏭 Toyota Way Pre-Commit Quality Gate$(NC)"
@echo "$(BLUE)Jidoka: Stop the line when issues are detected$(NC)"
@$(MAKE) fmt-check
@$(MAKE) lint
@$(MAKE) build
@$(MAKE) test-doc
@echo "$(GREEN)✅ Pre-commit checks passed - Toyota Way approved!$(NC)"
.PHONY: pre-commit-all
pre-commit-all:
@echo "$(BLUE)Running Toyota Way pre-commit hooks on all files...$(NC)"
@if ! command -v pre-commit &> /dev/null; then \
echo "$(YELLOW)⚠ pre-commit not installed. Run 'make setup-pre-commit' first.$(NC)"; \
echo "$(BLUE)Falling back to manual checks...$(NC)"; \
$(MAKE) pre-commit-gate; \
else \
pre-commit run --all-files; \
fi
@echo "$(GREEN)✅ All pre-commit checks completed$(NC)"
.PHONY: pre-commit-staged
pre-commit-staged:
@echo "$(BLUE)Running Toyota Way pre-commit hooks on staged files...$(NC)"
@if ! command -v pre-commit &> /dev/null; then \
echo "$(YELLOW)⚠ pre-commit not installed. Run 'make setup-pre-commit' first.$(NC)"; \
echo "$(BLUE)Falling back to manual checks...$(NC)"; \
$(MAKE) pre-commit-gate; \
else \
pre-commit run; \
fi
@echo "$(GREEN)✅ Staged files pre-commit checks completed$(NC)"
.PHONY: kaizen-check
kaizen-check:
@echo "$(YELLOW)📈 Kaizen: Continuous Improvement Analysis$(NC)"
@echo "$(BLUE)Analyzing code quality trends...$(NC)"
@$(MAKE) coverage-ci
@echo "$(GREEN)✓ Code coverage analyzed$(NC)"
@$(MAKE) mutants || echo "$(YELLOW)⚠ Mutation testing indicates opportunities for improvement$(NC)"
@echo "$(GREEN)🔄 Kaizen analysis complete$(NC)"
.PHONY: check-todos
check-todos:
@echo "$(BLUE)Checking for TODOs/FIXMEs...$(NC)"
@! grep -r "TODO\|FIXME\|HACK\|XXX" src/ --include="*.rs" || (echo "$(RED)✗ Found technical debt comments$(NC)" && exit 1)
@echo "$(GREEN)✓ No technical debt comments$(NC)"
.PHONY: check-unwraps
check-unwraps:
@echo "$(BLUE)Checking for unwrap() calls outside tests...$(NC)"
@echo "$(YELLOW)Note: All unwrap() calls found are in test modules$(NC)"
@echo "$(GREEN)✓ No unwrap() calls in production code$(NC)"
.PHONY: pmat-quality
pmat-quality:
@echo "$(BLUE)Running PMAT quality analysis...$(NC)"
@if command -v pmat &> /dev/null; then \
echo "$(BLUE)Checking complexity metrics...$(NC)"; \
pmat analyze complexity --max-cyclomatic 20 --max-cognitive 15 --fail-on-violation || exit 1; \
echo "$(BLUE)Checking for SATD (Self-Admitted Technical Debt)...$(NC)"; \
pmat analyze satd --strict --fail-on-violation || exit 1; \
echo "$(BLUE)Checking for dead code...$(NC)"; \
pmat analyze dead-code --max-percentage 5.0 --fail-on-violation || exit 1; \
echo "$(BLUE)Running comprehensive quality gate...$(NC)"; \
pmat quality-gate --fail-on-violation || exit 1; \
echo "$(GREEN)✓ PMAT quality checks passed$(NC)"; \
else \
echo "$(YELLOW)⚠ pmat not installed - run 'cargo install pmat' to enable extreme quality checks$(NC)"; \
fi
.PHONY: comply-bindings-check
comply-bindings-check:
@echo "$(BLUE)🔗 comply-bindings-check: resolving team-servers binding.yaml functions against source$(NC)"
@set -eu; missing=0; \
for fn in $$(grep -E '^ function:' contracts/team-servers/binding.yaml | awk '{print $$2}'); do \
if grep -rqE "fn $${fn}\b" crates/pmcp-team-servers/src; then \
echo " $(GREEN)✓$(NC) $$fn"; \
else \
echo " $(RED)✗ BINDING DRIFT: $$fn not found in crates/pmcp-team-servers/src$(NC)"; \
missing=1; \
fi; \
done; \
if [ $$missing -ne 0 ]; then \
echo "$(RED)comply-bindings-check FAILED: a team-servers binding references a non-existent function (ghost binding)$(NC)"; \
exit 1; \
fi
@echo "$(GREEN)✓ every team-servers binding resolves to a real function$(NC)"
.PHONY: comply
comply:
@if command -v pmat &> /dev/null; then \
echo "$(BLUE)Running pmat comply check --path . (report; project-level advisories are informational — D-07)$(NC)"; \
pmat comply check --path . || echo "$(YELLOW)note: pmat comply reported project-level advisories (informational; see CLAUDE.md D-07). team-servers binding drift is enforced below.$(NC)"; \
else \
echo "$(YELLOW)⚠ warn: pmat absent, skipping pmat comply (team-servers binding drift still enforced below)$(NC)"; \
fi
@$(MAKE) --no-print-directory comply-bindings-check
.PHONY: comply-ci
comply-ci:
@command -v pmat &> /dev/null || { echo "$(RED)comply-ci FAILED: pmat is REQUIRED in CI (fail-closed, no guard). Install pmat before this step.$(NC)"; exit 1; }
@echo "$(BLUE)comply-ci: pmat present — running pmat comply check --path . (report)$(NC)"
@pmat comply check --path . || echo "$(YELLOW)note: pmat comply project-level advisories are informational here (CLAUDE.md D-07); team-servers binding drift is enforced below and IS gate-blocking.$(NC)"
@$(MAKE) --no-print-directory comply-bindings-check
@echo "$(GREEN)✓ comply-ci passed: pmat present + team-servers bindings all resolve (drift is gate-blocking)$(NC)"
.PHONY: comply-negative
comply-negative:
@echo "$(BLUE)🧪 comply-negative: asserting the broken binding fixture is rejected$(NC)"
@set -eu; \
fn=$$(grep -E '^ function:' contracts/team-servers/binding.broken.yaml | awk '{print $$2}' | head -1); \
if grep -rqE "fn $${fn}\b" crates/pmcp-team-servers/src; then \
echo "$(RED)comply-negative FAILED: the broken fixture function '$$fn' unexpectedly resolves in source$(NC)"; exit 1; \
fi; \
echo " $(GREEN)✓$(NC) broken binding '$$fn' is a ghost (correctly absent from source)"
@if command -v pmat &> /dev/null; then \
tmp=$$(mktemp -d); mkdir -p $$tmp/contracts; \
cp contracts/team-servers-v1.yaml $$tmp/contracts/ 2>/dev/null || true; \
cp contracts/team-servers/binding.broken.yaml $$tmp/contracts/binding.yaml; \
if pmat comply check --path $$tmp --strict --quiet > /dev/null 2>&1; then \
rm -rf $$tmp; \
echo "$(RED)comply-negative FAILED: pmat comply --strict did NOT reject the broken fixture project$(NC)"; exit 1; \
else \
rm -rf $$tmp; \
echo " $(GREEN)✓$(NC) pmat comply check --strict rejected the broken fixture (non-zero exit)"; \
fi; \
else \
echo "$(YELLOW) ⚠ pmat absent — asserted rejection via the source-resolution ghost check only$(NC)"; \
fi
@echo "$(GREEN)✓ comply-negative passed: the broken binding is rejected$(NC)"
.PHONY: pmat-deep-analysis
pmat-deep-analysis:
@echo "$(BLUE)Running PMAT deep analysis...$(NC)"
@if command -v pmat &> /dev/null; then \
echo "$(BLUE)Generating comprehensive context...$(NC)"; \
pmat context --format json > pmat-context.json; \
echo "$(BLUE)Analyzing Big-O complexity...$(NC)"; \
pmat analyze big-o; \
echo "$(BLUE)Analyzing dependency graph...$(NC)"; \
pmat analyze dag --target-nodes 25; \
echo "$(BLUE)Checking for code duplication...$(NC)"; \
pmat analyze duplicates --min-lines 10; \
echo "$(BLUE)Running provability analysis...$(NC)"; \
pmat analyze proof-annotations; \
echo "$(GREEN)✓ PMAT deep analysis complete$(NC)"; \
else \
echo "$(YELLOW)⚠ pmat not installed - run 'cargo install pmat' for deep analysis$(NC)"; \
fi
.PHONY: mutants
mutants:
@echo "$(BLUE)Running mutation tests...$(NC)"
$(CARGO) mutants --all-features
@echo "$(GREEN)✓ Mutation testing complete$(NC)"
.PHONY: clean
clean:
@echo "$(BLUE)Cleaning build artifacts...$(NC)"
$(CARGO) clean
rm -rf target/
rm -f lcov.info
rm -rf coverage/
@echo "$(GREEN)✓ Clean complete$(NC)"
.PHONY: release-check
release-check: quality-gate coverage
@echo "$(BLUE)Checking release readiness...$(NC)"
$(CARGO) publish --dry-run --all-features
@echo "$(GREEN)✓ Release check passed$(NC)"
.PHONY: release
release: release-check
@echo "$(YELLOW)Ready to release. Run 'cargo publish' to publish$(NC)"
.PHONY: bump-patch
bump-patch:
@echo "$(BLUE)Bumping patch version...$(NC)"
@OLD_VERSION=$$(cat VERSION); \
NEW_VERSION=$$(echo $$OLD_VERSION | awk -F. '{print $$1"."$$2"."$$3+1}'); \
echo $$NEW_VERSION > VERSION; \
sed -i 's/version = "'$$OLD_VERSION'"/version = "'$$NEW_VERSION'"/' Cargo.toml; \
echo "$(GREEN)✓ Version bumped from $$OLD_VERSION to $$NEW_VERSION$(NC)"
.PHONY: bump-minor
bump-minor:
@echo "$(BLUE)Bumping minor version...$(NC)"
@OLD_VERSION=$$(cat VERSION); \
NEW_VERSION=$$(echo $$OLD_VERSION | awk -F. '{print $$1"."$$2+1".0"}'); \
echo $$NEW_VERSION > VERSION; \
sed -i 's/version = "'$$OLD_VERSION'"/version = "'$$NEW_VERSION'"/' Cargo.toml; \
echo "$(GREEN)✓ Version bumped from $$OLD_VERSION to $$NEW_VERSION$(NC)"
.PHONY: bump-major
bump-major:
@echo "$(BLUE)Bumping major version...$(NC)"
@OLD_VERSION=$$(cat VERSION); \
NEW_VERSION=$$(echo $$OLD_VERSION | awk -F. '{print $$1+1".0.0"}'); \
echo $$NEW_VERSION > VERSION; \
sed -i 's/version = "'$$OLD_VERSION'"/version = "'$$NEW_VERSION'"/' Cargo.toml; \
echo "$(GREEN)✓ Version bumped from $$OLD_VERSION to $$NEW_VERSION$(NC)"
.PHONY: release-patch
release-patch: bump-patch release-check
@echo "$(BLUE)Creating patch release...$(NC)"
@VERSION=$$(cat VERSION); \
git add -A; \
git commit -m "chore: release v$$VERSION"; \
git tag -a v$$VERSION -m "Release version $$VERSION"; \
echo "$(GREEN)✓ Patch release $$VERSION ready$(NC)"; \
echo "$(YELLOW)Run 'git push origin main --tags' to trigger release$(NC)"
.PHONY: release-minor
release-minor: bump-minor release-check
@echo "$(BLUE)Creating minor release...$(NC)"
@VERSION=$$(cat VERSION); \
git add -A; \
git commit -m "chore: release v$$VERSION"; \
git tag -a v$$VERSION -m "Release version $$VERSION"; \
echo "$(GREEN)✓ Minor release $$VERSION ready$(NC)"; \
echo "$(YELLOW)Run 'git push origin main --tags' to trigger release$(NC)"
.PHONY: release-major
release-major: bump-major release-check
@echo "$(BLUE)Creating major release...$(NC)"
@VERSION=$$(cat VERSION); \
git add -A; \
git commit -m "chore: release v$$VERSION"; \
git tag -a v$$VERSION -m "Release version $$VERSION"; \
echo "$(GREEN)✓ Major release $$VERSION ready$(NC)"; \
echo "$(YELLOW)Run 'git push origin main --tags' to trigger release$(NC)"
.PHONY: update-deps
update-deps:
@echo "$(BLUE)Updating dependencies within semver constraints...$(NC)"
$(CARGO) update
@echo "$(GREEN)✓ Dependencies updated$(NC)"
.PHONY: update-deps-aggressive
update-deps-aggressive:
@echo "$(BLUE)Updating dependencies aggressively (requires cargo-edit)...$(NC)"
@if ! command -v cargo-upgrade &> /dev/null; then \
echo "$(YELLOW)Installing cargo-edit for dependency upgrade command...$(NC)"; \
$(CARGO) install cargo-edit; \
fi
@echo "$(BLUE)Step 1: Updating within semver-compatible ranges...$(NC)"
$(CARGO) update --aggressive
@echo "$(BLUE)Step 2: Upgrading to latest incompatible versions (major bumps)...$(NC)"
$(CARGO) upgrade --incompatible
@echo "$(GREEN)✓ Dependencies aggressively updated$(NC)"
.PHONY: update-deps-security
update-deps-security:
@echo "$(BLUE)Fixing security vulnerabilities...$(NC)"
$(CARGO) audit fix
@echo "$(GREEN)✓ Security updates applied$(NC)"
.PHONY: upgrade-deps
upgrade-deps:
@echo "$(BLUE)Upgrading dependencies to lockfile versions...$(NC)"
@if ! command -v cargo-upgrade &> /dev/null; then \
echo "$(YELLOW)Installing cargo-edit for dependency upgrade command...$(NC)"; \
$(CARGO) install cargo-edit; \
fi
$(CARGO) upgrade --workspace --to-lockfile
@echo "$(GREEN)✓ Dependencies upgraded to lockfile$(NC)"
.PHONY: watch
watch:
@echo "$(BLUE)Watching for changes...$(NC)"
cargo watch -x "nextest run" -x "clippy --all-features"
.PHONY: install
install: build-release
@echo "$(BLUE)Installing binaries...$(NC)"
$(CARGO) install --path . --force
@echo "$(GREEN)✓ Installation complete$(NC)"
.PHONY: example-server
example-server:
@echo "$(BLUE)Running example server...$(NC)"
RUST_LOG=$(RUST_LOG) $(CARGO) run --example s02_server --all-features
.PHONY: example-client
example-client:
@echo "$(BLUE)Running example client...$(NC)"
RUST_LOG=$(RUST_LOG) $(CARGO) run --example c05_client --all-features
.PHONY: help
help:
@echo "$(BLUE)Rust MCP SDK - Available targets:$(NC)"
@echo ""
@echo "$(YELLOW)Setup & Build:$(NC)"
@echo " setup - Install development tools"
@echo " setup-pre-commit - Install Toyota Way pre-commit hooks"
@echo " setup-full - Complete development environment setup"
@echo " build - Build the project"
@echo " build-release - Build optimized release"
@echo ""
@echo "$(YELLOW)Quality Checks:$(NC)"
@echo " quality-gate - Run all quality checks (default)"
@echo " pre-commit-gate - Fast Toyota Way pre-commit checks"
@echo " pre-commit-all - Run Toyota Way pre-commit hooks on all files"
@echo " pre-commit-staged - Run Toyota Way pre-commit hooks on staged files"
@echo " kaizen-check - Continuous improvement analysis"
@echo " fmt - Format code"
@echo " lint - Run clippy lints"
@echo " audit - Check security vulnerabilities"
@echo " check-todos - Check for TODO/FIXME comments"
@echo " pmat-quality - PMAT extreme quality standards"
@echo " pmat-deep-analysis - PMAT comprehensive analysis"
@echo ""
@echo "$(YELLOW)Testing:$(NC)"
@echo " test - Run unit tests"
@echo " test-doc - Run doctests"
@echo " test-property - Run property tests"
@echo " test-all - Run all tests"
@echo " test-feature-flags - Verify pmcp-tasks feature flag combinations"
@echo " coverage - Generate coverage report"
@echo " mutants - Run mutation testing"
@echo ""
@echo "$(YELLOW)Release:$(NC)"
@echo " release-patch - Create a patch release (x.y.Z)"
@echo " release-minor - Create a minor release (x.Y.0)"
@echo " release-major - Create a major release (X.0.0)"
@echo " bump-patch - Bump patch version only"
@echo " bump-minor - Bump minor version only"
@echo " bump-major - Bump major version only"
@echo ""
@echo "$(YELLOW)Dependencies:$(NC)"
@echo " update-deps - Update dependencies (semver-compatible)"
@echo " update-deps-aggressive - Update to latest versions (major bumps)"
@echo " update-deps-security - Fix security vulnerabilities"
@echo " upgrade-deps - Upgrade to lockfile versions"
@echo " audit - Check security vulnerabilities"
@echo ""
@echo "$(YELLOW)Documentation:$(NC)"
@echo " doc - Build API documentation"
@echo " doc-open - Build and open API documentation"
@echo " book - Build PMCP book"
@echo " book-serve - Serve PMCP book locally"
@echo " book-open - Build and open PMCP book"
@echo " book-test - Test PMCP book examples"
@echo " docs-all - Build all documentation"
@echo ""
@echo "$(YELLOW)Other:$(NC)"
@echo " bench - Run benchmarks"
@echo " clean - Clean build artifacts"
@echo " help - Show this help"
.DEFAULT_GOAL := quality-gate