@salesforce/b2c-dx-mcp 0.4.3 → 0.4.5

package/README.md

@@ -2,25 +2,16 @@
 
 MCP (Model Context Protocol) server for Salesforce B2C Commerce developer experience tools.
 
-> ⚠️ **Active Development**: This package is under active development. Some tools are currently **placeholder implementations** that return mock responses. Tool implementations will be added incrementally.
+> [!NOTE]
+> This project is currently in **Developer Preview**. Tools are functional but require `--allow-non-ga-tools` to enable. Additional tools will be added in future releases.
 
-## Overview
+This MCP server enables AI assistants (Cursor, Claude Desktop, and others) to help with B2C Commerce development tasks. It provides toolsets for **SCAPI**, **CARTRIDGES**, **MRT**, **PWAV3**, and **STOREFRONTNEXT** development.
 
-This MCP server enables AI assistants to help with B2C Commerce development tasks. It provides toolsets for **SCAPI**, **CARTRIDGES**, **MRT**, **PWAV3**, and **STOREFRONTNEXT** development.
+Full documentation: [https://salesforcecommercecloud.github.io/b2c-developer-tooling/mcp/](https://salesforcecommercecloud.github.io/b2c-developer-tooling/mcp/)
 
-The server automatically detects your project type and enables relevant tools. See [Available Toolsets and Tools](#available-toolsets-and-tools) for details.
+## Installation
 
-## Usage
-
-### Project Directory and Auto-Discovery
-
-The most important flag is **`--project-directory`** (or env var `SFCC_PROJECT_DIRECTORY`). It tells the server where your project is located, enabling:
-
-1. **Auto-discovery** - Detects your project type and enables appropriate toolsets
-2. **Configuration loading** - Reads [`dw.json`](https://salesforcecommercecloud.github.io/b2c-developer-tooling/guide/configuration.html#configuration-file) from your project for credentials
-3. **Scaffolding** - Creates new files in the correct location
-
-> **Important:** MCP clients like Cursor and Claude Desktop spawn servers from the home directory (`~`), not your project. Always set `--project-directory`.
+**Prerequisites:** Node.js 22.0.0 or higher, MCP client (Cursor, Claude Desktop, or compatible)
 
 **Cursor** (supports `${workspaceFolder}`):
 
@@ -48,411 +39,132 @@ The most important flag is **`--project-directory`** (or env var `SFCC_PROJECT_D
 }
 ```
 
-### Project Type Detection
-
-The server analyzes your project directory and enables toolsets based on what it finds:
-
-| Project Type | Detection | Toolsets Enabled |
-|--------------|-----------|------------------|
-| **PWA Kit v3** | `@salesforce/pwa-kit-*`, `@salesforce/retail-react-app`, or `ccExtensibility` in package.json | PWAV3, MRT, SCAPI |
-| **Storefront Next** | Root or a workspace package has `@salesforce/storefront-next*` dependency, or package name starting with `storefront-next`. | STOREFRONTNEXT, MRT, CARTRIDGES, SCAPI |
-| **Cartridges** | `.project` file in cartridge directory | CARTRIDGES, SCAPI |
-| **No project detected** | No B2C markers found | SCAPI (base toolset only) |
-
-The **SCAPI** toolset is always enabled. Hybrid projects (e.g., cartridges + PWA Kit) get combined toolsets.
-
-### Manual Toolset Selection
-
-Override auto-discovery by specifying toolsets explicitly:
-
-```json
-"args": ["--project-directory", "${workspaceFolder}", "--toolsets", "CARTRIDGES,MRT", "--allow-non-ga-tools"]
-```
-
-### Prompting Tips and Examples
-
-AI assistants (like Cursor, Claude Desktop) automatically decide which MCP tools to use based on your prompts. To get the best results, use clear, specific prompts that describe what you want to accomplish.
-
-> ⚠️ **IMPORTANT**: **Explicitly mention "Use the MCP tool"** in your prompts for reliable tool usage. While AI assistants (like Cursor's Composer) can automatically select MCP tools based on context, explicit instructions ensure that the assistant prioritizes MCP tools over general knowledge, especially when multiple approaches are possible. This is particularly important for getting project-specific, up-to-date information rather than generic responses.
-
-#### Best Practices
-
-1. **Always explicitly request MCP tool usage** (see warning above): Start prompts with "Use the MCP tool to..." or include "Use the MCP tool" in your request.
-2. **Be specific about your goal**: Instead of "help me with Storefront Next", say "Use the MCP tool to show me how to build a product detail page with authentication"
-3. **Mention the tool or domain explicitly**: Reference the framework (Storefront Next, PWA Kit), operation (deploy, discover), or domain (SCAPI, cartridges)
-4. **Use natural language**: Describe what you want to achieve, not the tool name
-5. **Provide context**: Mention your project type, what you're building, or what you need to learn
-6. **Ask for guidelines first**: When starting a new project or learning a framework, ask for development guidelines before writing code
+See the [Installation Guide](https://salesforcecommercecloud.github.io/b2c-developer-tooling/mcp/installation) for detailed setup.
 
-#### Examples by Tool Category
+## Configuration
 
-##### Storefront Next Development Guidelines
+Always set `--project-directory` (or `SFCC_PROJECT_DIRECTORY`). MCP clients spawn from the home directory (`~`), not your project.
 
-The `storefront_next_development_guidelines` tool provides critical architecture rules and best practices. **Use this tool first** when starting new Storefront Next development or when you need architecture guidance.
+| Environment Variable | Description |
+|---------------------|-------------|
+| `SFCC_PROJECT_DIRECTORY` | Project directory (enables auto-discovery and config loading) |
+| `SFCC_SERVER` | B2C instance hostname |
+| `SFCC_USERNAME` | Username for WebDAV |
+| `SFCC_PASSWORD` | Password/access key for WebDAV |
+| `SFCC_CLIENT_ID` | OAuth client ID |
+| `SFCC_CLIENT_SECRET` | OAuth client secret |
+| `SFCC_MRT_API_KEY` | MRT API key |
 
-**Prompt examples:**
-- ✅ "I'm new to Storefront Next. Use the MCP tool to show me the critical rules I need to know."
-- ✅ "I need to build a product detail page. Use the MCP tool to show me best practices for data fetching and component patterns."
-- ✅ "I need to build a checkout form with authentication and validation. Use the MCP tool to show me how to handle form submissions, authentication, and internationalized error messages."
-- ✅ "Use the MCP tool to show me the data fetching patterns for Storefront Next."
-- ✅ "Show me all available Storefront Next development guidelines."
+See the [Configuration Guide](https://salesforcecommercecloud.github.io/b2c-developer-tooling/mcp/configuration) for credentials, flags, and toolset selection.
 
-**Available sections:**
-- `quick-reference` - Critical rules and architecture principles (default)
-- `data-fetching` - Data loading patterns with loaders
-- `state-management` - Client-side state management
-- `auth` - Authentication and session management
-- `components` - Component patterns and best practices
-- `styling` - Tailwind CSS 4, Shadcn/ui, styling guidelines
-- `page-designer` - Page Designer integration
-- `performance` - Performance optimization
-- `testing` - Testing strategies
-- `i18n` - Internationalization patterns
-- `config` - Configuration management
-- `extensions` - Extension development
-- `pitfalls` - Common pitfalls
+## Tools
 
-##### PWA Kit Development
+| Toolset | Tools | Docs |
+|---------|-------|------|
+| CARTRIDGES | `cartridge_deploy` | [toolsets#cartridges](https://salesforcecommercecloud.github.io/b2c-developer-tooling/mcp/toolsets#cartridges) |
+| MRT | `mrt_bundle_push` | [toolsets#mrt](https://salesforcecommercecloud.github.io/b2c-developer-tooling/mcp/toolsets#mrt) |
+| SCAPI | `scapi_schemas_list`, `scapi_custom_apis_status`, `scapi_customapi_scaffold` | [toolsets#scapi](https://salesforcecommercecloud.github.io/b2c-developer-tooling/mcp/toolsets#scapi) |
+| STOREFRONTNEXT | `storefront_next_development_guidelines`, `storefront_next_page_designer_decorator`, `storefront_next_site_theming`, `storefront_next_figma_to_component_workflow`, `storefront_next_generate_component`, `storefront_next_map_tokens_to_theme` | [toolsets#storefrontnext](https://salesforcecommercecloud.github.io/b2c-developer-tooling/mcp/toolsets#storefrontnext) |
+| PWAV3 | `pwakit_development_guidelines` + SCAPI tools | [toolsets#pwav3](https://salesforcecommercecloud.github.io/b2c-developer-tooling/mcp/toolsets#pwav3) |
 
-**Prompt examples:**
-- ✅ "I'm starting a new PWA Kit project. Use the MCP tool to get the development guidelines."
-- ✅ "Use the MCP tool to create a new product listing page component in my PWA Kit project."
-- ✅ "Use the MCP tool to recommend React hooks for fetching product data in PWA Kit."
+### cartridge_deploy
 
-##### SCAPI Discovery
+Deploy cartridges to a B2C Commerce instance. [Details](https://salesforcecommercecloud.github.io/b2c-developer-tooling/mcp/tools/cartridge-deploy)
 
-Use **scapi_schemas_list** for both standard SCAPI (Shop, Admin, Shopper APIs) and custom APIs. Use **scapi_custom_apis_status** for endpoint-level registration status (active/not_registered).
+- "Use the MCP tool to deploy my cartridges to the sandbox."
+- "Use the MCP tool to deploy only app_storefront_base."
 
-**SCAPI Schemas (tool: `scapi_schemas_list`):**
+### mrt_bundle_push
 
-Discover schema metadata and fetch OpenAPI specs for both standard and custom SCAPI:
+Build and push bundle to Managed Runtime. [Details](https://salesforcecommercecloud.github.io/b2c-developer-tooling/mcp/tools/mrt-bundle-push)
 
-**Standard SCAPI:**
-- ✅ "Use the MCP tool to list all available SCAPI schemas." → list mode (no includeSchemas).
-- ✅ "Use the MCP tool to show me what checkout APIs exist." → list with apiFamily: checkout.
-- ✅ "Use the MCP tool to discover SCAPI product endpoints." → list with apiFamily: product.
-- ✅ "Use the MCP tool to get the OpenAPI schema for shopper-baskets v1." → fetch with apiFamily, apiName, apiVersion, includeSchemas: true.
-- ✅ "Use the MCP tool to show me the full OpenAPI spec for shopper-products v1." → fetch with includeSchemas: true, expandAll: true.
+- "Use the MCP tool to push my Storefront Next bundle to staging."
+- "Use the MCP tool to deploy my PWA Kit bundle to production."
 
-**Custom APIs (use apiFamily: "custom"):**
-- ✅ "Use the MCP tool to list custom API definitions." → list with apiFamily: custom.
-- ✅ "Use the MCP tool to show me the loyalty-points custom API schema." → apiFamily: custom, apiName: loyalty-points, apiVersion: v1, includeSchemas: true.
+### scapi_schemas_list
 
-**Custom API Endpoint Status (tool: `scapi_custom_apis_status`):**
+List or fetch SCAPI schemas (standard and custom). [Details](https://salesforcecommercecloud.github.io/b2c-developer-tooling/mcp/tools/scapi-schemas-list)
 
-Get registration status of custom API endpoints deployed on the instance (remote only). Returns individual HTTP endpoints (e.g., GET /hello, POST /items/{id}) with registration status (active/not_registered), one row per endpoint per site. Requires OAuth with `sfcc.custom-apis` scope.
+- "Use the MCP tool to list all SCAPI schemas."
+- "Use the MCP tool to get the OpenAPI schema for shopper-baskets v1."
 
-- ✅ "Use the MCP tool to list custom SCAPI endpoints on my instance."
-- ✅ "Use the MCP tool to show which custom APIs are active vs not registered."
-- ✅ "Use the MCP tool to list custom API endpoints grouped by site." → groupBy: site
-- ✅ "Use the MCP tool to list custom API endpoints grouped by type." → groupBy: type
-- ✅ "Use the MCP tool to list only active custom API endpoints." → status: active
-- ✅ "Use the MCP tool to find custom API endpoints that failed to register." → status: not_registered
-- ✅ "Use the MCP tool to show endpoint details with all fields." → extended: true
-- ✅ "Use the MCP tool to show only apiName and status for active endpoints." → status: active, columns: "apiName,status"
+### scapi_custom_apis_status
 
-##### Cartridge Deployment
+Get custom API endpoint registration status. [Details](https://salesforcecommercecloud.github.io/b2c-developer-tooling/mcp/tools/scapi-custom-apis-status)
 
-**Prompt examples:**
-- ✅ "Use the MCP tool to deploy my cartridges to the sandbox instance."
-- ✅ "Use the MCP tool to deploy only the app_storefront_base cartridge to production."
-- ✅ "Use the MCP tool to deploy cartridges from the ./cartridges directory and reload the code version."
+- "Use the MCP tool to list custom API endpoints on my instance."
+- "Use the MCP tool to show which custom APIs are active vs not registered."
 
-##### MRT Bundle Operations
+### scapi_customapi_scaffold
 
-**Prompt examples:**
-- ✅ "Use the MCP tool to build and push my Storefront Next bundle to staging."
-- ✅ "Use the MCP tool to push the bundle from ./build directory to Managed Runtime."
-- ✅ "Use the MCP tool to deploy my PWA Kit or Storefront Next bundle to production with a deployment message."
+Generate new custom SCAPI endpoint in a cartridge. [Details](https://salesforcecommercecloud.github.io/b2c-developer-tooling/mcp/tools/scapi-custom-api-scaffold)
 
-#### Tips for Better Results
+- "Use the MCP tool to scaffold a new custom API named my-products."
+- "Use the MCP tool to create a custom admin API called customer-trips."
 
-- **Start with guidelines**: When learning a new framework, ask for development guidelines first using "Use the MCP tool to get..."
-- **Combine related topics**: Ask for multiple related sections (e.g., "data fetching and components") in one request
-- **Provide project context**: Mention your project type (Storefront Next, PWA Kit, cartridges) for better tool selection
-- **Specify operations clearly**: For deployment operations, mention the target (sandbox, staging, production) and what to deploy
+### storefront_next_development_guidelines
 
-### Configuration
+Get Storefront Next guidelines and best practices. [Details](https://salesforcecommercecloud.github.io/b2c-developer-tooling/mcp/tools/storefront-next-development-guidelines)
 
-Credentials can be provided via **config files** (recommended), **environment variables**, or **flags**. Priority: Flags > Env vars > Config files.
+- "Use the MCP tool to show me critical Storefront Next rules."
+- "Use the MCP tool to get data-fetching and component patterns."
 
-| Toolset | Required Credentials |
-|---------|---------------------|
-| **SCAPI** | `hostname` + `client-id` + `client-secret` (for `scapi_custom_apis_status`: requires `sfcc.custom-apis` scope) |
-| **CARTRIDGES** | `hostname` + `username` + `password` (or OAuth) |
-| **MRT** | `api-key` + `project` (optionally `environment`) |
-| **PWAV3** | `--project-directory` only (+ MRT config for deployments) |
-| **STOREFRONTNEXT** | `--project-directory` only (+ MRT/CARTRIDGES config for those tools) |
-
-**Option 1: Config files (recommended)**
-
-B2C credentials — [`dw.json`](https://salesforcecommercecloud.github.io/b2c-developer-tooling/guide/configuration.html#configuration-file) in your project root:
-```json
-{ "hostname": "xxx.demandware.net", "username": "...", "password": "...", "client-id": "...", "client-secret": "..." }
-```
-
-MRT credentials — [`~/.mobify`](https://salesforcecommercecloud.github.io/b2c-developer-tooling/guide/configuration.html#mobify-config-file) (create manually or via [B2C CLI](https://salesforcecommercecloud.github.io/b2c-developer-tooling/cli/mrt.html)):
-```json
-{ "api_key": "..." }
-```
-
-**Option 2: Environment variables**
-```json
-"env": { "SFCC_SERVER": "xxx.demandware.net", "SFCC_USERNAME": "...", "SFCC_PASSWORD": "...", "SFCC_MRT_API_KEY": "..." }
-```
-
-**Option 3: Flags**
-```json
-"args": ["--server", "xxx.demandware.net", "--username", "...", "--password", "...", "--api-key", "..."]
-```
-
-See [Flag Reference](#flag-reference) for all available flags and env vars.
-
-- `username`/`password` = B2C username + [WebDAV access key](https://help.salesforce.com/s/articleView?id=cc.b2c_account_manager_sso_use_webdav_file_access.htm&type=5)
-- `client-id`/`client-secret` = API client credentials from Account Manager
-
-### Flag Reference
-
-<details>
-<summary>Click to expand flag reference</summary>
-
-#### Core Flags
-
-| Flag | Env Variable | Description |
-|------|--------------|-------------|
-| `--project-directory` | `SFCC_PROJECT_DIRECTORY` | Project directory (enables auto-discovery and config loading) |
-| `--toolsets` | — | Comma-separated toolsets to enable |
-| `--tools` | — | Comma-separated individual tools to enable |
-| `--allow-non-ga-tools` | — | Enable experimental (non-GA) tools |
-| `--config` | — | Explicit path to [`dw.json`](https://salesforcecommercecloud.github.io/b2c-developer-tooling/guide/configuration.html#configuration-file) (advanced) |
-| `--log-level` | — | Logging verbosity (trace, debug, info, warn, error, silent) |
-| `--debug` | — | Enable debug logging |
-
-#### B2C Instance Flags
-
-| Flag | Env Variable | Description |
-|------|--------------|-------------|
-| `--server` | `SFCC_SERVER` | B2C instance hostname |
-| `--username` | `SFCC_USERNAME` | Username for Basic auth (WebDAV) |
-| `--password` | `SFCC_PASSWORD` | Password/access key for Basic auth |
-| `--client-id` | `SFCC_CLIENT_ID` | OAuth client ID |
-| `--client-secret` | `SFCC_CLIENT_SECRET` | OAuth client secret |
-| `--code-version` | `SFCC_CODE_VERSION` | Code version for deployments |
-
-#### MRT Flags
-
-| Flag | Env Variable | Description |
-|------|--------------|-------------|
-| `--api-key` | `SFCC_MRT_API_KEY` | MRT API key |
-| `--project` | `SFCC_MRT_PROJECT` | MRT project slug |
-| `--environment` | `SFCC_MRT_ENVIRONMENT` | MRT environment (staging, production) |
-| `--cloud-origin` | `SFCC_MRT_CLOUD_ORIGIN` | MRT cloud origin URL |
-
-</details>
-
-### Available Toolsets and Tools
-
-Use `--toolsets all` to enable all toolsets, or select specific ones with `--toolsets CARTRIDGES,MRT`.
-
-> **Note:** All tools are currently placeholder implementations. Use `--allow-non-ga-tools` flag to enable them.
-
-#### CARTRIDGES
-Cartridge development, deployment, and code version management.
-- **Status:** 🚧 Early Access
-
-| Tool | Description |
-|------|-------------|
-| `cartridge_deploy` | Deploy cartridges to a B2C Commerce instance |
-
-#### MRT
-Managed Runtime operations for PWA Kit and Storefront Next deployments.
-- **Status:** 🚧 Early Access
-
-| Tool | Description |
-|------|-------------|
-| `mrt_bundle_push` | Build, push bundle (optionally deploy) |
-
-#### PWAV3
-PWA Kit v3 development tools for building headless storefronts.
-- **Status:** 🚧 Placeholder
-
-| Tool | Description |
-|------|-------------|
-| `pwakit_create_storefront` | Create a new PWA Kit storefront project |
-| `pwakit_create_page` | Create a new page component in PWA Kit project |
-| `pwakit_create_component` | Create a new React component in PWA Kit project |
-| `pwakit_get_dev_guidelines` | Get PWA Kit development guidelines and best practices |
-| `pwakit_recommend_hooks` | Recommend appropriate React hooks for PWA Kit use cases |
-| `pwakit_run_site_test` | Run site tests for PWA Kit project |
-| `pwakit_install_agent_rules` | Install AI agent rules for PWA Kit development |
-| `scapi_schemas_list` | List or fetch SCAPI schemas (standard and custom). Use apiFamily: "custom" for custom APIs. |
-| `scapi_custom_apis_status` | Get registration status of custom API endpoints (active/not_registered). Remote only, requires OAuth. |
-| `mrt_bundle_push` | Build, push bundle (optionally deploy) |
-
-#### SCAPI
-Salesforce Commerce API discovery and exploration.
-- **Status:** 🚧 Early Access
-
-| Tool | Description |
-|------|-------------|
-| `scapi_schemas_list` | List or fetch SCAPI schemas (standard and custom). Use apiFamily: "custom" for custom APIs. |
-| `scapi_custom_apis_status` | Get registration status of custom API endpoints (active/not_registered). Remote only, requires OAuth. |
-| `scapi_customapi_scaffold` | Scaffold a new custom SCAPI API (not yet implemented) |
-
-#### STOREFRONTNEXT
-Storefront Next development tools for building modern storefronts.
-- **Status:** 🚧 Placeholder
-
-| Tool | Description |
-|------|-------------|
-| `storefront_next_development_guidelines` | Get Storefront Next development guidelines and best practices |
-| `storefront_next_site_theming` | Configure and manage site theming for Storefront Next |
-| `storefront_next_figma_to_component_workflow` | Convert Figma designs to Storefront Next components |
-| `storefront_next_generate_component` | Generate a new Storefront Next component |
-| `storefront_next_map_tokens_to_theme` | Map design tokens to Storefront Next theme configuration |
-| `storefront_next_page_designer_decorator` | Add Page Designer decorators to Storefront Next components |
-| `storefront_next_generate_page_designer_metadata` | Generate Page Designer metadata for Storefront Next components |
-| `scapi_schemas_list` | List or fetch SCAPI schemas (standard and custom). Use apiFamily: "custom" for custom APIs. |
-| `scapi_custom_apis_status` | Get registration status of custom API endpoints (active/not_registered). Remote only, requires OAuth. |
-| `mrt_bundle_push` | Build, push bundle (optionally deploy) |
-
-> **Note:** Some tools appear in multiple toolsets (e.g., `mrt_bundle_push`, `scapi_schemas_list`, `scapi_custom_apis_status`). When using multiple toolsets, tools are automatically deduplicated.
-
-## Telemetry
+### storefront_next_page_designer_decorator
 
-The MCP server collects anonymous usage telemetry to help improve the developer experience. Telemetry is enabled by default.
+Add Page Designer decorators to components. [Details](https://salesforcecommercecloud.github.io/b2c-developer-tooling/mcp/tools/storefront-next-page-designer-decorator)
 
-**Development mode**: Telemetry is automatically disabled when using `bin/dev.js`, so local development and testing won't pollute production data.
+- "Use the MCP tool to add Page Designer decorators to my component."
 
-### Configuring telemetry
+### storefront_next_site_theming
 
-Set options in the `env` object of your server entry in `.cursor/mcp.json` or `~/.cursor/mcp.json` (the client injects these when it starts the server):
+Get theming guidelines, questions, and WCAG color validation for Storefront Next. [Details](https://salesforcecommercecloud.github.io/b2c-developer-tooling/mcp/tools/storefront-next-site-theming)
 
-- **Disable**: `SF_DISABLE_TELEMETRY=true` or `SFCC_DISABLE_TELEMETRY=true`
-- **Custom endpoint**: `SFCC_APP_INSIGHTS_KEY=your-key`
+- "Use the MCP tool to help me apply my brand colors to my Storefront Next site."
+- "Use the MCP tool to validate my color combinations for accessibility."
 
-### What We Collect
+### storefront_next_figma_to_component_workflow
 
-- **Server lifecycle events**: When the server starts, stops, or encounters errors
-- **Tool usage**: Which tools are called and their execution time (not the arguments or results)
-- **Command metrics**: Command duration and success/failure status
-- **Environment info**: Platform, architecture, Node.js version, and package version
+Workflow orchestrator for Figma-to-component conversion. Parses Figma URL, returns step-by-step instructions for subsequent tool calls. Requires external Figma MCP server. [Details](https://salesforcecommercecloud.github.io/b2c-developer-tooling/mcp/tools/storefront-next-figma-to-component-workflow) — [Figma Setup](https://salesforcecommercecloud.github.io/b2c-developer-tooling/mcp/figma-tools-setup)
 
-### What We Don't Collect
+- "Use the MCP tool to convert this Figma design to a Storefront Next component: [Figma URL with node-id]"
+- "Use the MCP tool to create this homepage from the Figma design: [Figma URL with node-id]"
 
-- **No credentials**: No API keys, passwords, or secrets
-- **No business data**: No product data, customer information, or site content
-- **No tool arguments**: No input parameters or output results from tool calls
-- **No file contents**: No source code, configuration files, or project data
+### storefront_next_generate_component
 
-## Development
+Analyze Figma design and discovered components to recommend REUSE, EXTEND, or CREATE strategy. [Details](https://salesforcecommercecloud.github.io/b2c-developer-tooling/mcp/tools/storefront-next-generate-component)
 
-### Quick Start
+- "Use the MCP tool to analyze the Figma design and recommend whether to reuse, extend, or create a component."
 
-```bash
-# Install dependencies (from monorepo root)
-pnpm install
+### storefront_next_map_tokens_to_theme
 
-# Navigate to the package directory
-cd packages/b2c-dx-mcp
+Map Figma design tokens to existing theme tokens in app.css with confidence scores and suggestions. [Details](https://salesforcecommercecloud.github.io/b2c-developer-tooling/mcp/tools/storefront-next-map-tokens-to-theme)
 
-# Launch MCP Inspector for development (no build needed, uses TypeScript directly)
-pnpm run inspect:dev
+- "Use the MCP tool to map these Figma design tokens to my theme."
 
-# Launch MCP Inspector with production build (runs build first)
-pnpm run inspect
+### pwakit_development_guidelines
 
-# Build the package
-pnpm run build
+Get PWA Kit v3 guidelines. [Details](https://salesforcecommercecloud.github.io/b2c-developer-tooling/mcp/tools/pwakit-development-guidelines)
 
-# Run tests (includes linting)
-pnpm run test
+- "Use the MCP tool to get PWA Kit development guidelines."
 
-# Format code
-pnpm run format
+## Prompting Tips
 
-# Run linter only
-pnpm run lint
+Explicitly mention "Use the MCP tool" in your prompts for reliable tool usage. See [Prompting Tips](https://salesforcecommercecloud.github.io/b2c-developer-tooling/mcp/#prompting-tips) for best practices and more examples.
 
-# Clean build artifacts
-pnpm run clean
-```
-
-### Project Directory
-
-Commands should be run from the `packages/b2c-dx-mcp` directory:
-
-```bash
-cd packages/b2c-dx-mcp
-```
-
-Or use pnpm's filter flag from the monorepo root:
-
-```bash
-pnpm --filter @salesforce/b2c-dx-mcp run <script>
-```
-
-### Testing the MCP Server Locally
-
-#### 1. MCP Inspector
-
-Use MCP Inspector to browse tools and test them in a web UI:
-
-```bash
-pnpm run inspect:dev
-```
-
-This runs TypeScript directly (no build needed). Open the localhost URL shown in the terminal, click **Connect**, then **List Tools** to see available tools.
-
-For CLI-based testing:
-
-```bash
-# List all tools
-npx mcp-inspector --cli node bin/dev.js --toolsets all --allow-non-ga-tools --method tools/list
-
-# Call a specific tool
-npx mcp-inspector --cli node bin/dev.js --toolsets all --allow-non-ga-tools \
-  --method tools/call \
-  --tool-name storefront_next_page_designer_decorator
-```
-
-#### 2. IDE Integration
-
-Configure your IDE to use the local MCP server. Add this to your IDE's MCP configuration:
-
-```json
-{
-  "mcpServers": {
-    "b2c-dx-local": {
-      "command": "node",
-      "args": [
-        "/full/path/to/packages/b2c-dx-mcp/bin/dev.js",
-        "--toolsets", "all",
-        "--allow-non-ga-tools"
-      ]
-    }
-  }
-}
-```
+## Telemetry
 
-> **Note:** Make sure that the script is executable: `chmod +x /full/path/to/packages/b2c-dx-mcp/bin/dev.js`
->
-> The script's shebang (`#!/usr/bin/env -S node --conditions development`) handles Node.js setup automatically.
+The MCP server collects anonymous usage telemetry by default. Disable with `SF_DISABLE_TELEMETRY=true` or `SFCC_DISABLE_TELEMETRY=true` in your MCP client's `env` config. See the [MCP documentation](https://salesforcecommercecloud.github.io/b2c-developer-tooling/mcp/#telemetry) for details.
 
-> **Note:** Restart the MCP server in your IDE to pick up code changes.
+## Documentation
 
-#### 3. JSON-RPC via stdin
+Full documentation: [https://salesforcecommercecloud.github.io/b2c-developer-tooling/](https://salesforcecommercecloud.github.io/b2c-developer-tooling/)
 
-Send raw MCP protocol messages:
+For MCP development, testing, and local setup, see [CONTRIBUTING.md](./CONTRIBUTING.md).
 
-```bash
-# List all tools (--allow-non-ga-tools required for placeholder tools)
-echo '{"jsonrpc":"2.0","id":1,"method":"tools/list"}' | node bin/dev.js --toolsets all --allow-non-ga-tools
+## License
 
-# Call a specific tool
-echo '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"cartridge_deploy","arguments":{}}}' | node bin/dev.js --toolsets all --allow-non-ga-tools
-```
+This project is licensed under the Apache License 2.0. See [LICENSE.txt](../../LICENSE.txt) for full details.
 
-## License
+## Disclaimer
 
-Apache-2.0
+This project is currently in **Developer Preview** and is provided "as-is" without warranty of any kind. It is not yet generally available (GA) and should not be used in production environments. Features, APIs, and functionality may change without notice in future releases.