@salesforce/b2c-dx-mcp 0.3.2 → 0.4.0

package/dist/tools/page-designer-decorator/rules.js

@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2025, Salesforce, Inc.
+ * SPDX-License-Identifier: Apache-2
+ * For full license text, see the license.txt file in the repo root or http://www.apache.org/licenses/LICENSE-2.0
+ */
+// Import all rule renderers
+import { renderModeSelection } from './rules/1-mode-selection.js';
+import { renderInteractiveOverview } from './rules/2b-0-interactive-overview.js';
+import { renderAnalyzeStep } from './rules/2b-1-interactive-analyze.js';
+import { renderSelectPropsConfirmation } from './rules/2b-2-interactive-select-props.js';
+import { renderConfigureAttrs } from './rules/2b-3-interactive-configure-attrs.js';
+import { renderConfigureRegions } from './rules/2b-4-interactive-configure-regions.js';
+import { renderConfirmGeneration } from './rules/2b-5-interactive-confirm-generation.js';
+import { renderAutoMode } from './rules/2a-auto-mode.js';
+/**
+ * Page Designer decorator rules - type-safe, zero dependencies
+ */
+export const pageDesignerDecoratorRules = {
+    /**
+     * Renders the mode selection prompt
+     */
+    getModeSelectionInstructions(context) {
+        return renderModeSelection(context);
+    },
+    /**
+     * Renders the interactive mode workflow overview
+     */
+    getInteractiveOverview() {
+        return renderInteractiveOverview();
+    },
+    /**
+     * Renders Interactive Analyze step instructions
+     */
+    getAnalyzeInstructions(context) {
+        const workflow = this.getInteractiveOverview();
+        const stepContent = renderAnalyzeStep(context);
+        return `${workflow}\n\n${stepContent}`;
+    },
+    /**
+     * Renders Interactive Select Props step confirmation
+     */
+    getSelectPropsConfirmation(context) {
+        return renderSelectPropsConfirmation(context);
+    },
+    /**
+     * Renders Interactive Configure Attributes step instructions
+     */
+    getConfigureAttrsInstructions(context) {
+        return renderConfigureAttrs(context);
+    },
+    /**
+     * Renders Interactive Configure Regions step instructions
+     */
+    getConfigureRegionsInstructions(context) {
+        return renderConfigureRegions(context);
+    },
+    /**
+     * Renders Interactive Confirm Generation step (final code presentation)
+     */
+    getConfirmGenerationInstructions(context) {
+        return renderConfirmGeneration(context);
+    },
+    /**
+     * Renders Auto Mode instructions
+     */
+    getAutoModeInstructions(context) {
+        return renderAutoMode(context);
+    },
+};
+//# sourceMappingURL=rules.js.map

package/dist/tools/page-designer-decorator/templates/decorator-generator.d.ts

@@ -0,0 +1,116 @@
+export interface AttributeContext {
+    name: string;
+    tsType: string;
+    optional: boolean;
+    hasConfig: boolean;
+    config?: {
+        id?: string;
+        type?: string;
+        name?: string;
+        description?: string;
+        defaultValue?: unknown;
+        required?: boolean;
+        values?: string[];
+    };
+}
+export interface RegionContext {
+    id: string;
+    name: string;
+    description?: string;
+    maxComponents?: number;
+    componentTypeInclusions?: string[];
+    componentTypeExclusions?: string[];
+}
+export interface MetadataContext {
+    needsImports: boolean;
+    componentId: string;
+    componentName: string;
+    componentDescription: string;
+    componentGroup?: string;
+    metadataClassName: string;
+    hasAttributes: boolean;
+    hasRegions: boolean;
+    hasLoader: boolean;
+    regions: RegionContext[];
+    attributes: AttributeContext[];
+}
+/**
+ * Generate complete Page Designer decorator code for a React component
+ *
+ * **This is the main code generation function.**
+ *
+ * Produces a TypeScript class with decorators that:
+ * 1. Registers the component in Page Designer
+ * 2. Defines editable attributes (props)
+ * 3. Optionally defines nested content regions
+ *
+ * **Output structure:**
+ * ```typescript
+ * import { Component } from '...';
+ * import { AttributeDefinition } from '...';
+ *
+ * @Component('component-id', {
+ *   name: 'Component Name',
+ *   description: '...',
+ *   group: 'category'
+ * })
+ * @RegionDefinition([...]) // Optional
+ * export class ComponentMetadata {
+ *   @AttributeDefinition({ ... })
+ *   prop1!: string;
+ *
+ *   @AttributeDefinition()
+ *   prop2?: number;
+ * }
+ * ```
+ *
+ * **Generated code must be:**
+ * - Added to the component file (after imports, before component)
+ * - Compiled with TypeScript
+ * - Used by `generate_page_designer_metadata` tool to create JSON metadata
+ *
+ * @param context - Complete metadata context
+ * @returns TypeScript code string ready to paste into component file
+ *
+ * @example
+ * // Simple component with attributes:
+ * generateDecoratorCode({
+ *   needsImports: true,
+ *   componentId: 'hero-banner',
+ *   componentName: 'Hero Banner',
+ *   componentDescription: 'Large hero section with image and CTA',
+ *   componentGroup: 'content',
+ *   metadataClassName: 'HeroBannerMetadata',
+ *   hasAttributes: true,
+ *   hasRegions: false,
+ *   hasLoader: false,
+ *   regions: [],
+ *   attributes: [
+ *     { name: 'title', tsType: 'string', optional: false, hasConfig: false },
+ *     { name: 'imageUrl', tsType: 'string', optional: false, hasConfig: true,
+ *       config: { type: 'image', name: 'Background Image' } }
+ *   ]
+ * })
+ *
+ * @example
+ * // Layout component with regions:
+ * generateDecoratorCode({
+ *   needsImports: true,
+ *   componentId: 'two-column',
+ *   componentName: 'Two Column Layout',
+ *   componentDescription: 'Side-by-side content layout',
+ *   componentGroup: 'layout',
+ *   metadataClassName: 'TwoColumnMetadata',
+ *   hasAttributes: false,
+ *   hasRegions: true,
+ *   hasLoader: false,
+ *   regions: [
+ *     { id: 'left', name: 'Left Column' },
+ *     { id: 'right', name: 'Right Column' }
+ *   ],
+ *   attributes: []
+ * })
+ *
+ * @public
+ */
+export declare function generateDecoratorCode(context: MetadataContext): string;

package/dist/tools/page-designer-decorator/templates/decorator-generator.js

@@ -0,0 +1,350 @@
+/*
+ * Copyright (c) 2025, Salesforce, Inc.
+ * SPDX-License-Identifier: Apache-2
+ * For full license text, see the license.txt file in the repo root or http://www.apache.org/licenses/LICENSE-2.0
+ */
+/**
+ * Generate a simple attribute decorator with auto-inferred type
+ *
+ * **Simple attributes** use default Page Designer behavior:
+ * - Type is inferred from TypeScript type
+ * - No custom configuration needed
+ * - Minimal decorator syntax
+ *
+ * **When to use:**
+ * - Basic string, number, or boolean props
+ * - No special validation or defaults needed
+ * - Standard field naming is acceptable
+ *
+ * @param attr - Attribute context
+ * @returns TypeScript code string for the attribute
+ *
+ * @example
+ * // Input:
+ * { name: 'title', tsType: 'string', optional: false, hasConfig: false }
+ *
+ * // Output:
+ * `@AttributeDefinition()
+ * title!: string;`
+ *
+ * @internal
+ */
+function generateSimpleAttribute(attr) {
+    return `    @AttributeDefinition()
+    ${attr.name}${attr.optional ? '?' : '!'}: ${attr.tsType};`;
+}
+/**
+ * Generate a configured attribute decorator with explicit settings
+ *
+ * **Configured attributes** specify custom Page Designer behavior:
+ * - Explicit `type` (url, image, enum, etc.)
+ * - Custom `name` for display in Page Designer UI
+ * - `description` for merchant guidance
+ * - `defaultValue` for new instances
+ * - `required` flag for validation
+ * - `values` array for enum types
+ *
+ * **When to use:**
+ * - URL, image, or rich text fields (need specific editors)
+ * - Enum fields with predefined options
+ * - Fields with default values
+ * - Fields with merchant-friendly names
+ *
+ * @param attr - Attribute context with configuration
+ * @returns TypeScript code string for the configured attribute
+ *
+ * @example
+ * // Input (URL field):
+ * {
+ *   name: 'ctaUrl',
+ *   tsType: 'string',
+ *   optional: false,
+ *   hasConfig: true,
+ *   config: {
+ *     type: 'url',
+ *     name: 'CTA Button URL',
+ *     description: 'Destination URL for the call-to-action button'
+ *   }
+ * }
+ *
+ * // Output:
+ * `@AttributeDefinition({
+ *     type: 'url',
+ *     name: 'CTA Button URL',
+ *     description: 'Destination URL for the call-to-action button',
+ * })
+ * ctaUrl!: string;`
+ *
+ * @example
+ * // Input (Enum field):
+ * {
+ *   name: 'variant',
+ *   tsType: 'string',
+ *   optional: false,
+ *   hasConfig: true,
+ *   config: {
+ *     type: 'enum',
+ *     name: 'Button Variant',
+ *     values: ['primary', 'secondary', 'outline'],
+ *     defaultValue: 'primary'
+ *   }
+ * }
+ *
+ * // Output:
+ * `@AttributeDefinition({
+ *     type: 'enum',
+ *     name: 'Button Variant',
+ *     defaultValue: 'primary',
+ *     values: ['primary', 'secondary', 'outline'],
+ * })
+ * variant!: string;`
+ *
+ * @internal
+ */
+function generateConfiguredAttribute(attr) {
+    if (!attr.config) {
+        return generateSimpleAttribute(attr);
+    }
+    const config = attr.config;
+    const configLines = [];
+    if (config.id) {
+        configLines.push(`        id: '${config.id}',`);
+    }
+    if (config.name) {
+        configLines.push(`        name: '${config.name}',`);
+    }
+    if (config.type) {
+        configLines.push(`        type: '${config.type}',`);
+    }
+    if (config.description) {
+        configLines.push(`        description: '${config.description}',`);
+    }
+    if (config.defaultValue !== undefined) {
+        const valueStr = typeof config.defaultValue === 'string' ? `'${config.defaultValue}'` : JSON.stringify(config.defaultValue);
+        configLines.push(`        defaultValue: ${valueStr},`);
+    }
+    if (config.required !== undefined) {
+        configLines.push(`        required: ${config.required},`);
+    }
+    if (config.values && config.values.length > 0) {
+        configLines.push(`        values: [${config.values.map((v) => `'${v}'`).join(', ')}],`);
+    }
+    return `    @AttributeDefinition({
+${configLines.join('\n')}
+    })
+    ${attr.name}${attr.optional ? '?' : '!'}: ${attr.tsType};`;
+}
+/**
+ * Generate import statements for Page Designer decorators
+ *
+ * **Decision logic:**
+ * - Always imports `Component` (required for all decorated components)
+ * - Conditionally imports `AttributeDefinition` (if component has editable props)
+ * - Conditionally imports `RegionDefinition` (if component has nested content areas)
+ *
+ * **Why conditional:**
+ * Avoids unused imports that would trigger linting warnings.
+ *
+ * @param context - Metadata context indicating what's needed
+ * @returns TypeScript import statements with trailing newlines
+ *
+ * @example
+ * // Component with attributes only:
+ * generateImports({ needsImports: true, hasAttributes: true, hasRegions: false })
+ * // => `import { Component } from '@/lib/decorators/component';
+ * //     import { AttributeDefinition } from '@/lib/decorators/attribute-definition';\n\n`
+ *
+ * @example
+ * // Component with regions:
+ * generateImports({ needsImports: true, hasAttributes: true, hasRegions: true })
+ * // => All three decorators imported
+ *
+ * @internal
+ */
+function generateImports(context) {
+    if (!context.needsImports) {
+        return '';
+    }
+    const imports = [`import { Component } from '@/lib/decorators/component';`];
+    if (context.hasAttributes) {
+        imports.push(`import { AttributeDefinition } from '@/lib/decorators/attribute-definition';`);
+    }
+    if (context.hasRegions) {
+        imports.push(`import { RegionDefinition } from '@/lib/decorators';`);
+    }
+    return `${imports.join('\n')}\n\n`;
+}
+/**
+ * Generate @RegionDefinition decorator for nested content areas
+ *
+ * **Regions** define areas where merchants can add nested components in Page Designer.
+ * Common use cases:
+ * - Layout containers (grid cells, columns)
+ * - Content sections (header, body, footer)
+ * - Tab panels, accordion items
+ *
+ * **Configuration options:**
+ * - `id`: Unique identifier for the region
+ * - `name`: Display name in Page Designer
+ * - `description`: Merchant guidance
+ * - `maxComponents`: Limit number of nested components
+ * - `componentTypeInclusions`: Whitelist of allowed component types
+ * - `componentTypeExclusions`: Blacklist of disallowed component types
+ *
+ * @param context - Metadata context with region definitions
+ * @returns TypeScript code for @RegionDefinition decorator or empty string
+ *
+ * @example
+ * // Simple region:
+ * {
+ *   hasRegions: true,
+ *   regions: [{
+ *     id: 'main',
+ *     name: 'Main Content Area',
+ *     description: 'Add content components here'
+ *   }]
+ * }
+ * // => `@RegionDefinition([
+ * //       {
+ * //         id: 'main',
+ * //         name: 'Main Content Area',
+ * //         description: 'Add content components here',
+ * //       }
+ * //     ])\n`
+ *
+ * @example
+ * // Constrained region:
+ * {
+ *   hasRegions: true,
+ *   regions: [{
+ *     id: 'grid',
+ *     name: 'Product Grid',
+ *     maxComponents: 12,
+ *     componentTypeInclusions: ['product-tile', 'product-card']
+ *   }]
+ * }
+ *
+ * @internal
+ */
+function generateRegionDefinition(context) {
+    if (!context.hasRegions || context.regions.length === 0) {
+        return '';
+    }
+    const regionsDef = context.regions
+        .map((region) => {
+        const lines = [`    {`, `        id: '${region.id}',`, `        name: '${region.name}',`];
+        if (region.description) {
+            lines.push(`        description: '${region.description}',`);
+        }
+        if (region.maxComponents !== undefined) {
+            lines.push(`        maxComponents: ${region.maxComponents},`);
+        }
+        if (region.componentTypeInclusions && region.componentTypeInclusions.length > 0) {
+            lines.push(`        componentTypeInclusions: [${region.componentTypeInclusions.map((t) => `'${t}'`).join(', ')}],`);
+        }
+        if (region.componentTypeExclusions && region.componentTypeExclusions.length > 0) {
+            lines.push(`        componentTypeExclusions: [${region.componentTypeExclusions.map((t) => `'${t}'`).join(', ')}],`);
+        }
+        lines.push(`    }`);
+        return lines.join('\n');
+    })
+        .join(',\n');
+    return `@RegionDefinition([\n${regionsDef}\n])\n`;
+}
+/**
+ * Generate complete Page Designer decorator code for a React component
+ *
+ * **This is the main code generation function.**
+ *
+ * Produces a TypeScript class with decorators that:
+ * 1. Registers the component in Page Designer
+ * 2. Defines editable attributes (props)
+ * 3. Optionally defines nested content regions
+ *
+ * **Output structure:**
+ * ```typescript
+ * import { Component } from '...';
+ * import { AttributeDefinition } from '...';
+ *
+ * @Component('component-id', {
+ *   name: 'Component Name',
+ *   description: '...',
+ *   group: 'category'
+ * })
+ * @RegionDefinition([...]) // Optional
+ * export class ComponentMetadata {
+ *   @AttributeDefinition({ ... })
+ *   prop1!: string;
+ *
+ *   @AttributeDefinition()
+ *   prop2?: number;
+ * }
+ * ```
+ *
+ * **Generated code must be:**
+ * - Added to the component file (after imports, before component)
+ * - Compiled with TypeScript
+ * - Used by `generate_page_designer_metadata` tool to create JSON metadata
+ *
+ * @param context - Complete metadata context
+ * @returns TypeScript code string ready to paste into component file
+ *
+ * @example
+ * // Simple component with attributes:
+ * generateDecoratorCode({
+ *   needsImports: true,
+ *   componentId: 'hero-banner',
+ *   componentName: 'Hero Banner',
+ *   componentDescription: 'Large hero section with image and CTA',
+ *   componentGroup: 'content',
+ *   metadataClassName: 'HeroBannerMetadata',
+ *   hasAttributes: true,
+ *   hasRegions: false,
+ *   hasLoader: false,
+ *   regions: [],
+ *   attributes: [
+ *     { name: 'title', tsType: 'string', optional: false, hasConfig: false },
+ *     { name: 'imageUrl', tsType: 'string', optional: false, hasConfig: true,
+ *       config: { type: 'image', name: 'Background Image' } }
+ *   ]
+ * })
+ *
+ * @example
+ * // Layout component with regions:
+ * generateDecoratorCode({
+ *   needsImports: true,
+ *   componentId: 'two-column',
+ *   componentName: 'Two Column Layout',
+ *   componentDescription: 'Side-by-side content layout',
+ *   componentGroup: 'layout',
+ *   metadataClassName: 'TwoColumnMetadata',
+ *   hasAttributes: false,
+ *   hasRegions: true,
+ *   hasLoader: false,
+ *   regions: [
+ *     { id: 'left', name: 'Left Column' },
+ *     { id: 'right', name: 'Right Column' }
+ *   ],
+ *   attributes: []
+ * })
+ *
+ * @public
+ */
+export function generateDecoratorCode(context) {
+    const imports = generateImports(context);
+    const componentDecorator = `@Component('${context.componentId}', {
+    name: '${context.componentName}',
+    description: '${context.componentDescription}',${context.componentGroup ? `\n    group: '${context.componentGroup}',` : ''}
+})`;
+    const regionDefinition = generateRegionDefinition(context);
+    const attributes = context.attributes
+        .map((attr) => {
+        return attr.hasConfig ? generateConfiguredAttribute(attr) : generateSimpleAttribute(attr);
+    })
+        .join('\n\n');
+    return `${imports}${componentDecorator}
+${regionDefinition}export class ${context.metadataClassName} {
+${attributes}
+}`;
+}
+//# sourceMappingURL=decorator-generator.js.map

package/dist/tools/pwav3/index.d.ts

@@ -7,7 +7,7 @@ import type { Services } from '../../services.js';
  * toolsets: ["MRT", "PWAV3", "STOREFRONTNEXT"] and will
  * automatically appear in PWAV3.
  *
- * @param services - MCP services
+ * @param loadServices - Function that loads configuration and returns Services instance
  * @returns Array of MCP tools
  */
-export declare function createPwav3Tools(services: Services): McpTool[];
+export declare function createPwav3Tools(loadServices: () => Services): McpTool[];

package/dist/tools/pwav3/index.js

@@ -25,10 +25,10 @@ import { createToolAdapter, jsonResult } from '../adapter.js';
  * @param name - Tool name
  * @param description - Tool description
  * @param toolsets - Toolsets this tool belongs to
- * @param services - MCP services
+ * @param loadServices - Function that loads configuration and returns Services instance
  * @returns The configured MCP tool
  */
-function createPlaceholderTool(name, description, toolsets, services) {
+function createPlaceholderTool(name, description, toolsets, loadServices) {
     return createToolAdapter({
         name,
         description: `[PLACEHOLDER] ${description}`,
@@ -50,7 +50,7 @@ function createPlaceholderTool(name, description, toolsets, services) {
             };
         },
         formatOutput: (output) => jsonResult(output),
-    }, services);
+    }, loadServices);
 }
 /**
  * Creates all tools for the PWAV3 toolset.
@@ -59,20 +59,20 @@ function createPlaceholderTool(name, description, toolsets, services) {
  * toolsets: ["MRT", "PWAV3", "STOREFRONTNEXT"] and will
  * automatically appear in PWAV3.
  *
- * @param services - MCP services
+ * @param loadServices - Function that loads configuration and returns Services instance
  * @returns Array of MCP tools
  */
-export function createPwav3Tools(services) {
+export function createPwav3Tools(loadServices) {
     return [
         // PWA Kit development tools
-        createPlaceholderTool('pwakit_create_storefront', 'Create a new PWA Kit storefront project', ['PWAV3'], services),
-        createPlaceholderTool('pwakit_create_page', 'Create a new page component in PWA Kit project', ['PWAV3'], services),
-        createPlaceholderTool('pwakit_create_component', 'Create a new React component in PWA Kit project', ['PWAV3'], services),
-        createPlaceholderTool('pwakit_get_dev_guidelines', 'Get PWA Kit development guidelines and best practices', ['PWAV3'], services),
-        createPlaceholderTool('pwakit_recommend_hooks', 'Recommend appropriate React hooks for PWA Kit use cases', ['PWAV3'], services),
-        createPlaceholderTool('pwakit_run_site_test', 'Run site tests for PWA Kit project', ['PWAV3'], services),
-        createPlaceholderTool('pwakit_install_agent_rules', 'Install AI agent rules for PWA Kit development', ['PWAV3'], services),
-        createPlaceholderTool('pwakit_explore_scapi_shop_api', 'Explore SCAPI Shop API endpoints and capabilities', ['PWAV3'], services),
+        createPlaceholderTool('pwakit_create_storefront', 'Create a new PWA Kit storefront project', ['PWAV3'], loadServices),
+        createPlaceholderTool('pwakit_create_page', 'Create a new page component in PWA Kit project', ['PWAV3'], loadServices),
+        createPlaceholderTool('pwakit_create_component', 'Create a new React component in PWA Kit project', ['PWAV3'], loadServices),
+        createPlaceholderTool('pwakit_get_dev_guidelines', 'Get PWA Kit development guidelines and best practices', ['PWAV3'], loadServices),
+        createPlaceholderTool('pwakit_recommend_hooks', 'Recommend appropriate React hooks for PWA Kit use cases', ['PWAV3'], loadServices),
+        createPlaceholderTool('pwakit_run_site_test', 'Run site tests for PWA Kit project', ['PWAV3'], loadServices),
+        createPlaceholderTool('pwakit_install_agent_rules', 'Install AI agent rules for PWA Kit development', ['PWAV3'], loadServices),
+        createPlaceholderTool('pwakit_explore_scapi_shop_api', 'Explore SCAPI Shop API endpoints and capabilities', ['PWAV3'], loadServices),
     ];
 }
 //# sourceMappingURL=index.js.map

package/dist/tools/scapi/index.d.ts

@@ -1,9 +1,17 @@
+/**
+ * SCAPI toolset for B2C Commerce.
+ *
+ * This toolset provides MCP tools for Salesforce Commerce API (SCAPI) discovery and exploration.
+ * Includes both standard SCAPI schemas and custom API status tools.
+ *
+ * @module tools/scapi
+ */
 import type { McpTool } from '../../utils/index.js';
 import type { Services } from '../../services.js';
 /**
  * Creates all tools for the SCAPI toolset.
  *
- * @param services - MCP services
+ * @param loadServices - Function that loads configuration and returns Services instance
  * @returns Array of MCP tools
  */
-export declare function createScapiTools(services: Services): McpTool[];
+export declare function createScapiTools(loadServices: () => Services): McpTool[];

package/dist/tools/scapi/index.js

@@ -3,66 +3,15 @@
  * SPDX-License-Identifier: Apache-2
  * For full license text, see the license.txt file in the repo root or http://www.apache.org/licenses/LICENSE-2.0
  */
-/**
- * SCAPI toolset for B2C Commerce.
- *
- * This toolset provides MCP tools for Salesforce Commerce API (SCAPI) discovery and exploration.
- *
- * > ⚠️ **PLACEHOLDER - ACTIVE DEVELOPMENT**
- * > Tools in this module are placeholder implementations that return mock responses.
- * > Actual implementations are coming soon. Use `--allow-non-ga-tools` flag to enable.
- *
- * @module tools/scapi
- */
-import { z } from 'zod';
-import { createToolAdapter, jsonResult } from '../adapter.js';
-/**
- * Creates a placeholder tool for SCAPI operations.
- *
- * Placeholder tools log invocations and return mock responses until
- * the actual implementation is available.
- *
- * @param name - Tool name
- * @param description - Tool description
- * @param toolsets - Toolsets this tool belongs to
- * @param services - MCP services
- * @returns The configured MCP tool
- */
-function createPlaceholderTool(name, description, toolsets, services) {
-    return createToolAdapter({
-        name,
-        description: `[PLACEHOLDER] ${description}`,
-        toolsets,
-        isGA: false,
-        requiresInstance: true,
-        inputSchema: {
-            message: z.string().optional().describe('Optional message to echo'),
-        },
-        async execute(args) {
-            // Placeholder implementation
-            const timestamp = new Date().toISOString();
-            return {
-                tool: name,
-                status: 'placeholder',
-                message: `This is a placeholder implementation for '${name}'. The actual implementation is coming soon.`,
-                input: args,
-                timestamp,
-            };
-        },
-        formatOutput: (output) => jsonResult(output),
-    }, services);
-}
+import { createScapiSchemasListTool } from './scapi-schemas-list.js';
+import { createScapiCustomApisStatusTool } from './scapi-custom-apis-status.js';
 /**
  * Creates all tools for the SCAPI toolset.
  *
- * @param services - MCP services
+ * @param loadServices - Function that loads configuration and returns Services instance
  * @returns Array of MCP tools
  */
-export function createScapiTools(services) {
-    return [
-        createPlaceholderTool('scapi_discovery', 'Discover available SCAPI endpoints and capabilities', ['PWAV3', 'SCAPI', 'STOREFRONTNEXT'], services),
-        createPlaceholderTool('scapi_customapi_scaffold', 'Scaffold a new custom SCAPI API', ['SCAPI'], services),
-        createPlaceholderTool('scapi_custom_api_discovery', 'Discover custom SCAPI API endpoints', ['PWAV3', 'SCAPI', 'STOREFRONTNEXT'], services),
-    ];
+export function createScapiTools(loadServices) {
+    return [createScapiSchemasListTool(loadServices), createScapiCustomApisStatusTool(loadServices)];
 }
 //# sourceMappingURL=index.js.map