@salesforce/b2c-tooling-sdk 0.0.0-nightly.20260119053920

package/dist/cjs/config/types.d.ts

@@ -0,0 +1,270 @@
+/**
+ * Configuration types for the B2C SDK.
+ *
+ * This module defines the canonical configuration format and interfaces
+ * for the configuration resolution system.
+ *
+ * @module config/types
+ */
+import type { AuthMethod, AuthStrategy } from '../auth/types.js';
+import type { B2CInstance } from '../instance/index.js';
+import type { MrtClient } from '../platform/mrt.js';
+/**
+ * Normalized B2C configuration with camelCase fields.
+ *
+ * This is the canonical intermediate format that all configuration sources
+ * map to. It provides a consistent interface regardless of the source format
+ * (dw.json uses kebab-case, env vars use SCREAMING_SNAKE_CASE, etc.).
+ */
+export interface NormalizedConfig {
+    /** B2C instance hostname */
+    hostname?: string;
+    /** Separate hostname for WebDAV operations (if different from main hostname) */
+    webdavHostname?: string;
+    /** Code version for deployments */
+    codeVersion?: string;
+    /** Username for Basic auth (WebDAV) */
+    username?: string;
+    /** Password/access-key for Basic auth (WebDAV) */
+    password?: string;
+    /** OAuth client ID */
+    clientId?: string;
+    /** OAuth client secret */
+    clientSecret?: string;
+    /** OAuth scopes */
+    scopes?: string[];
+    /** Allowed authentication methods in priority order */
+    authMethods?: AuthMethod[];
+    /** Account Manager hostname for OAuth (default: account.demandware.com) */
+    accountManagerHost?: string;
+    /** SCAPI short code */
+    shortCode?: string;
+    /** MRT project slug */
+    mrtProject?: string;
+    /** MRT environment name (e.g., staging, production) */
+    mrtEnvironment?: string;
+    /** MRT API key */
+    mrtApiKey?: string;
+    /** MRT API origin URL override */
+    mrtOrigin?: string;
+    /** Instance name (from multi-config supporting sources) */
+    instanceName?: string;
+}
+/**
+ * Warning codes for configuration resolution.
+ */
+export type ConfigWarningCode = 'HOSTNAME_MISMATCH' | 'DEPRECATED_FIELD' | 'MISSING_REQUIRED' | 'SOURCE_ERROR';
+/**
+ * A warning generated during configuration resolution.
+ */
+export interface ConfigWarning {
+    /** Warning code for programmatic handling */
+    code: ConfigWarningCode;
+    /** Human-readable warning message */
+    message: string;
+    /** Additional details about the warning */
+    details?: Record<string, unknown>;
+}
+/**
+ * Information about a configuration source that contributed to resolution.
+ */
+export interface ConfigSourceInfo {
+    /** Human-readable name of the source */
+    name: string;
+    /** Location of the source (file path, keychain entry, URL, etc.) */
+    location?: string;
+    /** All fields that this source provided values for */
+    fields: (keyof NormalizedConfig)[];
+    /** Fields that were not used because a higher priority source already provided them */
+    fieldsIgnored?: (keyof NormalizedConfig)[];
+}
+/**
+ * Result of configuration resolution.
+ */
+export interface ConfigResolutionResult {
+    /** The resolved configuration */
+    config: NormalizedConfig;
+    /** Warnings generated during resolution */
+    warnings: ConfigWarning[];
+    /** Information about which sources contributed to the config */
+    sources: ConfigSourceInfo[];
+}
+/**
+ * Options for configuration resolution.
+ */
+export interface ResolveConfigOptions {
+    /** Named instance for supporting ConfigSources */
+    instance?: string;
+    /** Explicit path to config file (defaults to auto-discover) */
+    configPath?: string;
+    /** Starting directory for config file search */
+    startDir?: string;
+    /** Whether to apply hostname mismatch protection (default: true) */
+    hostnameProtection?: boolean;
+    /** Cloud origin for ~/.mobify lookup (MRT) */
+    cloudOrigin?: string;
+    /** Path to custom MRT credentials file (overrides default ~/.mobify) */
+    credentialsFile?: string;
+    /** Account Manager hostname for OAuth (passed to plugins for host-specific config) */
+    accountManagerHost?: string;
+    /**
+     * Custom sources to add BEFORE default sources (higher priority).
+     * These sources can override values from dw.json and ~/.mobify.
+     */
+    sourcesBefore?: ConfigSource[];
+    /**
+     * Custom sources to add AFTER default sources (lower priority).
+     * These sources fill in gaps left by dw.json and ~/.mobify.
+     */
+    sourcesAfter?: ConfigSource[];
+    /** Replace default sources entirely (instead of appending) */
+    replaceDefaultSources?: boolean;
+}
+/**
+ * Result of loading configuration from a source.
+ */
+export interface ConfigLoadResult {
+    /** The loaded configuration */
+    config: NormalizedConfig;
+    /**
+     * Location of the source (for diagnostics).
+     * May be a file path, keychain entry, URL, or other identifier.
+     */
+    location?: string;
+}
+/**
+ * A configuration source that can contribute config values.
+ *
+ * Implement this interface to create custom configuration sources.
+ * Sources are called in order, and later sources can override earlier ones.
+ *
+ * @example
+ * ```typescript
+ * import type { ConfigSource, ConfigLoadResult, ResolveConfigOptions } from '@salesforce/b2c-tooling-sdk/config';
+ *
+ * class MyCustomSource implements ConfigSource {
+ *   name = 'my-custom-source';
+ *
+ *   load(options: ResolveConfigOptions): ConfigLoadResult | undefined {
+ *     // Load config from your custom source
+ *     return { config: { hostname: 'example.com' }, location: '/path/to/config' };
+ *   }
+ * }
+ * ```
+ */
+export interface ConfigSource {
+    /** Human-readable name for diagnostics */
+    name: string;
+    /**
+     * Load configuration from this source.
+     *
+     * @param options - Resolution options
+     * @returns Config and location from this source, or undefined if source not available
+     */
+    load(options: ResolveConfigOptions): ConfigLoadResult | undefined;
+}
+/**
+ * Options for creating OAuth auth strategy.
+ */
+export interface CreateOAuthOptions {
+    /** Allowed OAuth methods (default: ['client-credentials', 'implicit']) */
+    allowedMethods?: AuthMethod[];
+}
+/**
+ * Options for creating MRT client.
+ */
+export interface CreateMrtClientOptions {
+    /** MRT organization (currently unused but required by MrtClient) */
+    org?: string;
+    /** MRT project slug (overrides config value) */
+    project?: string;
+    /** MRT environment name (overrides config value) */
+    env?: string;
+}
+/**
+ * Result of configuration resolution with factory methods.
+ *
+ * Provides both raw configuration values and factory methods for creating
+ * B2C SDK objects (B2CInstance, AuthStrategy, MrtClient) based on the
+ * resolved configuration.
+ *
+ * @example
+ * ```typescript
+ * import { resolveConfig } from '@salesforce/b2c-tooling-sdk/config';
+ *
+ * const config = resolveConfig({
+ *   hostname: process.env.SFCC_SERVER,
+ *   clientId: process.env.SFCC_CLIENT_ID,
+ * });
+ *
+ * if (config.hasB2CInstanceConfig()) {
+ *   const instance = config.createB2CInstance();
+ *   await instance.webdav.propfind('Cartridges');
+ * }
+ *
+ * if (config.hasMrtConfig()) {
+ *   const mrtAuth = config.createMrtAuth();
+ * }
+ * ```
+ */
+export interface ResolvedB2CConfig {
+    /** Raw configuration values */
+    readonly values: NormalizedConfig;
+    /** Warnings generated during resolution */
+    readonly warnings: ConfigWarning[];
+    /** Information about which sources contributed to the config */
+    readonly sources: ConfigSourceInfo[];
+    /**
+     * Check if B2C instance configuration is available.
+     * Requires: hostname
+     */
+    hasB2CInstanceConfig(): boolean;
+    /**
+     * Check if MRT configuration is available.
+     * Requires: mrtApiKey
+     */
+    hasMrtConfig(): boolean;
+    /**
+     * Check if OAuth configuration is available.
+     * Requires: clientId
+     */
+    hasOAuthConfig(): boolean;
+    /**
+     * Check if Basic auth configuration is available.
+     * Requires: username and password
+     */
+    hasBasicAuthConfig(): boolean;
+    /**
+     * Creates a B2CInstance from the resolved configuration.
+     * @throws Error if hostname is not configured
+     */
+    createB2CInstance(): B2CInstance;
+    /**
+     * Creates a Basic auth strategy.
+     * @throws Error if username or password is not configured
+     */
+    createBasicAuth(): AuthStrategy;
+    /**
+     * Creates an OAuth auth strategy.
+     * @param options - OAuth options (allowed methods)
+     * @throws Error if clientId is not configured
+     */
+    createOAuth(options?: CreateOAuthOptions): AuthStrategy;
+    /**
+     * Creates an MRT auth strategy (API key).
+     * @throws Error if mrtApiKey is not configured
+     */
+    createMrtAuth(): AuthStrategy;
+    /**
+     * Creates a WebDAV auth strategy.
+     * Prefers Basic auth if available, falls back to OAuth.
+     * @throws Error if neither Basic auth nor OAuth is configured
+     */
+    createWebDavAuth(): AuthStrategy;
+    /**
+     * Creates an MRT client.
+     * @param options - MRT project/environment options
+     * @throws Error if mrtApiKey is not configured
+     */
+    createMrtClient(options?: CreateMrtClientOptions): MrtClient;
+}

package/dist/cjs/config/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/cjs/config/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/config/types.ts"],"names":[],"mappings":""}

package/dist/cjs/defaults.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Centralized default values for B2C Commerce APIs.
+ *
+ * These defaults are used across auth strategies, clients, and CLI commands.
+ * Override via environment variables or CLI flags.
+ *
+ * @module defaults
+ */
+/**
+ * Default Account Manager host for OAuth authentication.
+ * Used for client credentials and implicit OAuth flows.
+ *
+ * Environment variable: SFCC_ACCOUNT_MANAGER_HOST
+ */
+export declare const DEFAULT_ACCOUNT_MANAGER_HOST = "account.demandware.com";
+/**
+ * Default ODS (On-Demand Sandbox) API host.
+ * Used for sandbox management operations.
+ *
+ * Environment variable: SFCC_SANDBOX_API_HOST
+ */
+export declare const DEFAULT_ODS_HOST = "admin.dx.commercecloud.salesforce.com";

package/dist/cjs/defaults.js

@@ -0,0 +1,28 @@
+/*
+ * 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
+ */
+/**
+ * Centralized default values for B2C Commerce APIs.
+ *
+ * These defaults are used across auth strategies, clients, and CLI commands.
+ * Override via environment variables or CLI flags.
+ *
+ * @module defaults
+ */
+/**
+ * Default Account Manager host for OAuth authentication.
+ * Used for client credentials and implicit OAuth flows.
+ *
+ * Environment variable: SFCC_ACCOUNT_MANAGER_HOST
+ */
+export const DEFAULT_ACCOUNT_MANAGER_HOST = 'account.demandware.com';
+/**
+ * Default ODS (On-Demand Sandbox) API host.
+ * Used for sandbox management operations.
+ *
+ * Environment variable: SFCC_SANDBOX_API_HOST
+ */
+export const DEFAULT_ODS_HOST = 'admin.dx.commercecloud.salesforce.com';
+//# sourceMappingURL=defaults.js.map

package/dist/cjs/defaults.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.js","sourceRoot":"","sources":["../../src/defaults.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH;;;;;;;GAOG;AAEH;;;;;GAKG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAG,wBAAwB,CAAC;AAErE;;;;;GAKG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,uCAAuC,CAAC"}

package/dist/cjs/discovery/detector.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Workspace detection implementation.
+ *
+ * @module discovery/detector
+ */
+import type { DetectionResult, DetectOptions } from './types.js';
+/**
+ * Detects the type of B2C Commerce project in a workspace.
+ *
+ * WorkspaceTypeDetector analyzes a directory to determine what kind of
+ * Commerce project it contains. Returns ALL matched project types to enable
+ * union toolset selection for hybrid projects.
+ *
+ * @example
+ * ```typescript
+ * import { WorkspaceTypeDetector } from '@salesforce/b2c-tooling-sdk/discovery';
+ *
+ * const detector = new WorkspaceTypeDetector('/path/to/project');
+ * const result = await detector.detect();
+ *
+ * console.log(`Project types: ${result.projectTypes.join(', ')}`);
+ * console.log(`Matched patterns: ${result.matchedPatterns.join(', ')}`);
+ * ```
+ *
+ * @example Custom patterns
+ * ```typescript
+ * const detector = new WorkspaceTypeDetector('/path/to/project', {
+ *   additionalPatterns: [myCustomPattern],
+ *   excludePatterns: ['sfra-cartridge'],
+ * });
+ * ```
+ */
+export declare class WorkspaceTypeDetector {
+    private workspacePath;
+    private patterns;
+    /**
+     * Creates a new WorkspaceTypeDetector.
+     *
+     * @param workspacePath - Path to the workspace directory to analyze
+     * @param options - Detection options for customizing behavior
+     */
+    constructor(workspacePath: string, options?: DetectOptions);
+    /**
+     * Performs workspace detection.
+     *
+     * Runs all configured patterns against the workspace and returns
+     * a consolidated result with all detected project types.
+     *
+     * @returns Detection result with all project types and matched patterns
+     */
+    detect(): Promise<DetectionResult>;
+    /**
+     * Resolves patterns based on options.
+     */
+    private resolvePatterns;
+}
+/**
+ * Creates a WorkspaceTypeDetector and performs detection in one call.
+ *
+ * This is a convenience function for simple detection use cases.
+ *
+ * @param workspacePath - Path to the workspace directory
+ * @param options - Detection options
+ * @returns Detection result with all matched project types
+ *
+ * @example
+ * ```typescript
+ * import { detectWorkspaceType } from '@salesforce/b2c-tooling-sdk/discovery';
+ *
+ * const result = await detectWorkspaceType(process.cwd());
+ * console.log(`Detected types: ${result.projectTypes.join(', ')}`);
+ * console.log(`Patterns: ${result.matchedPatterns.join(', ')}`);
+ * ```
+ */
+export declare function detectWorkspaceType(workspacePath: string, options?: DetectOptions): Promise<DetectionResult>;

package/dist/cjs/discovery/detector.js

@@ -0,0 +1,108 @@
+import { DEFAULT_PATTERNS } from './patterns/index.js';
+/**
+ * Detects the type of B2C Commerce project in a workspace.
+ *
+ * WorkspaceTypeDetector analyzes a directory to determine what kind of
+ * Commerce project it contains. Returns ALL matched project types to enable
+ * union toolset selection for hybrid projects.
+ *
+ * @example
+ * ```typescript
+ * import { WorkspaceTypeDetector } from '@salesforce/b2c-tooling-sdk/discovery';
+ *
+ * const detector = new WorkspaceTypeDetector('/path/to/project');
+ * const result = await detector.detect();
+ *
+ * console.log(`Project types: ${result.projectTypes.join(', ')}`);
+ * console.log(`Matched patterns: ${result.matchedPatterns.join(', ')}`);
+ * ```
+ *
+ * @example Custom patterns
+ * ```typescript
+ * const detector = new WorkspaceTypeDetector('/path/to/project', {
+ *   additionalPatterns: [myCustomPattern],
+ *   excludePatterns: ['sfra-cartridge'],
+ * });
+ * ```
+ */
+export class WorkspaceTypeDetector {
+    workspacePath;
+    patterns;
+    /**
+     * Creates a new WorkspaceTypeDetector.
+     *
+     * @param workspacePath - Path to the workspace directory to analyze
+     * @param options - Detection options for customizing behavior
+     */
+    constructor(workspacePath, options = {}) {
+        this.workspacePath = workspacePath;
+        this.patterns = this.resolvePatterns(options);
+    }
+    /**
+     * Performs workspace detection.
+     *
+     * Runs all configured patterns against the workspace and returns
+     * a consolidated result with all detected project types.
+     *
+     * @returns Detection result with all project types and matched patterns
+     */
+    async detect() {
+        const matchedPatterns = [];
+        const projectTypes = [];
+        for (const pattern of this.patterns) {
+            try {
+                if (await pattern.detect(this.workspacePath)) {
+                    matchedPatterns.push(pattern.name);
+                    // Add project type if not already present
+                    if (!projectTypes.includes(pattern.projectType)) {
+                        projectTypes.push(pattern.projectType);
+                    }
+                }
+            }
+            catch {
+                // Skip patterns that fail to detect - could log in debug mode
+            }
+        }
+        return {
+            projectTypes,
+            matchedPatterns,
+            autoDiscovered: true,
+        };
+    }
+    /**
+     * Resolves patterns based on options.
+     */
+    resolvePatterns(options) {
+        let patterns = options.patterns ?? DEFAULT_PATTERNS;
+        if (options.additionalPatterns) {
+            patterns = [...patterns, ...options.additionalPatterns];
+        }
+        if (options.excludePatterns) {
+            patterns = patterns.filter((p) => !options.excludePatterns.includes(p.name));
+        }
+        return patterns;
+    }
+}
+/**
+ * Creates a WorkspaceTypeDetector and performs detection in one call.
+ *
+ * This is a convenience function for simple detection use cases.
+ *
+ * @param workspacePath - Path to the workspace directory
+ * @param options - Detection options
+ * @returns Detection result with all matched project types
+ *
+ * @example
+ * ```typescript
+ * import { detectWorkspaceType } from '@salesforce/b2c-tooling-sdk/discovery';
+ *
+ * const result = await detectWorkspaceType(process.cwd());
+ * console.log(`Detected types: ${result.projectTypes.join(', ')}`);
+ * console.log(`Patterns: ${result.matchedPatterns.join(', ')}`);
+ * ```
+ */
+export async function detectWorkspaceType(workspacePath, options) {
+    const detector = new WorkspaceTypeDetector(workspacePath, options);
+    return detector.detect();
+}
+//# sourceMappingURL=detector.js.map

package/dist/cjs/discovery/detector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"detector.js","sourceRoot":"","sources":["../../../src/discovery/detector.ts"],"names":[],"mappings":"AAWA,OAAO,EAAC,gBAAgB,EAAC,MAAM,qBAAqB,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,OAAO,qBAAqB;IACxB,aAAa,CAAS;IACtB,QAAQ,CAAqB;IAErC;;;;;OAKG;IACH,YAAY,aAAqB,EAAE,UAAyB,EAAE;QAC5D,IAAI,CAAC,aAAa,GAAG,aAAa,CAAC;QACnC,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;IAChD,CAAC;IAED;;;;;;;OAOG;IACH,KAAK,CAAC,MAAM;QACV,MAAM,eAAe,GAAa,EAAE,CAAC;QACrC,MAAM,YAAY,GAAkB,EAAE,CAAC;QAEvC,KAAK,MAAM,OAAO,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;YACpC,IAAI,CAAC;gBACH,IAAI,MAAM,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC;oBAC7C,eAAe,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;oBACnC,0CAA0C;oBAC1C,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE,CAAC;wBAChD,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;oBACzC,CAAC;gBACH,CAAC;YACH,CAAC;YAAC,MAAM,CAAC;gBACP,8DAA8D;YAChE,CAAC;QACH,CAAC;QAED,OAAO;YACL,YAAY;YACZ,eAAe;YACf,cAAc,EAAE,IAAI;SACrB,CAAC;IACJ,CAAC;IAED;;OAEG;IACK,eAAe,CAAC,OAAsB;QAC5C,IAAI,QAAQ,GAAG,OAAO,CAAC,QAAQ,IAAI,gBAAgB,CAAC;QAEpD,IAAI,OAAO,CAAC,kBAAkB,EAAE,CAAC;YAC/B,QAAQ,GAAG,CAAC,GAAG,QAAQ,EAAE,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC;QAC1D,CAAC;QAED,IAAI,OAAO,CAAC,eAAe,EAAE,CAAC;YAC5B,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,eAAgB,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;QAChF,CAAC;QAED,OAAO,QAAQ,CAAC;IAClB,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,KAAK,UAAU,mBAAmB,CAAC,aAAqB,EAAE,OAAuB;IACtF,MAAM,QAAQ,GAAG,IAAI,qBAAqB,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC;IACnE,OAAO,QAAQ,CAAC,MAAM,EAAE,CAAC;AAC3B,CAAC"}

package/dist/cjs/discovery/index.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Workspace discovery for B2C Commerce projects.
+ *
+ * This module provides utilities for detecting the type of B2C Commerce
+ * project in a workspace. Returns ALL matched project types to enable
+ * union toolset selection for hybrid projects.
+ *
+ * ## Quick Start
+ *
+ * ```typescript
+ * import { detectWorkspaceType } from '@salesforce/b2c-tooling-sdk/discovery';
+ *
+ * const result = await detectWorkspaceType(process.cwd());
+ *
+ * console.log(`Project types: ${result.projectTypes.join(', ')}`);
+ * console.log(`Matched patterns: ${result.matchedPatterns.join(', ')}`);
+ * ```
+ *
+ * ## Project Types
+ *
+ * The detector recognizes 3 workspace types:
+ *
+ * - `cartridges` - Any cartridge-based project (detected via .project files)
+ * - `pwa-kit-v3` - PWA Kit v3 storefront
+ * - `storefront-next` - Storefront Next/Odyssey project
+ *
+ * ## Toolset Mapping
+ *
+ * - base (fallback): SCAPI
+ * - cartridges: CARTRIDGES + SCAPI
+ * - pwa-kit-v3: PWAV3 + MRT + SCAPI
+ * - storefront-next: STOREFRONTNEXT + MRT + SCAPI
+ *
+ * ## Custom Patterns
+ *
+ * You can extend detection with custom patterns:
+ *
+ * ```typescript
+ * import { WorkspaceTypeDetector, type DetectionPattern } from '@salesforce/b2c-tooling-sdk/discovery';
+ *
+ * const myPattern: DetectionPattern = {
+ *   name: 'my-framework',
+ *   projectType: 'cartridges',
+ *   detect: async (path) => {
+ *     // Custom detection logic
+ *     return false;
+ *   },
+ * };
+ *
+ * const detector = new WorkspaceTypeDetector('/path/to/project', {
+ *   additionalPatterns: [myPattern],
+ * });
+ *
+ * const result = await detector.detect();
+ * ```
+ *
+ * @module discovery
+ */
+export { WorkspaceTypeDetector, detectWorkspaceType } from './detector.js';
+export type { ProjectType, DetectionPattern, DetectionResult, DetectOptions } from './types.js';
+export { DEFAULT_PATTERNS, cartridgesPattern, pwaKitV3Pattern, storefrontNextPattern, sfraPattern, } from './patterns/index.js';
+export { readPackageJson, exists, glob, globDirs } from './utils.js';
+export type { PackageJson } from './utils.js';

package/dist/cjs/discovery/index.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
+ */
+/**
+ * Workspace discovery for B2C Commerce projects.
+ *
+ * This module provides utilities for detecting the type of B2C Commerce
+ * project in a workspace. Returns ALL matched project types to enable
+ * union toolset selection for hybrid projects.
+ *
+ * ## Quick Start
+ *
+ * ```typescript
+ * import { detectWorkspaceType } from '@salesforce/b2c-tooling-sdk/discovery';
+ *
+ * const result = await detectWorkspaceType(process.cwd());
+ *
+ * console.log(`Project types: ${result.projectTypes.join(', ')}`);
+ * console.log(`Matched patterns: ${result.matchedPatterns.join(', ')}`);
+ * ```
+ *
+ * ## Project Types
+ *
+ * The detector recognizes 3 workspace types:
+ *
+ * - `cartridges` - Any cartridge-based project (detected via .project files)
+ * - `pwa-kit-v3` - PWA Kit v3 storefront
+ * - `storefront-next` - Storefront Next/Odyssey project
+ *
+ * ## Toolset Mapping
+ *
+ * - base (fallback): SCAPI
+ * - cartridges: CARTRIDGES + SCAPI
+ * - pwa-kit-v3: PWAV3 + MRT + SCAPI
+ * - storefront-next: STOREFRONTNEXT + MRT + SCAPI
+ *
+ * ## Custom Patterns
+ *
+ * You can extend detection with custom patterns:
+ *
+ * ```typescript
+ * import { WorkspaceTypeDetector, type DetectionPattern } from '@salesforce/b2c-tooling-sdk/discovery';
+ *
+ * const myPattern: DetectionPattern = {
+ *   name: 'my-framework',
+ *   projectType: 'cartridges',
+ *   detect: async (path) => {
+ *     // Custom detection logic
+ *     return false;
+ *   },
+ * };
+ *
+ * const detector = new WorkspaceTypeDetector('/path/to/project', {
+ *   additionalPatterns: [myPattern],
+ * });
+ *
+ * const result = await detector.detect();
+ * ```
+ *
+ * @module discovery
+ */
+// Main API
+export { WorkspaceTypeDetector, detectWorkspaceType } from './detector.js';
+// Patterns (for customization)
+export { DEFAULT_PATTERNS, cartridgesPattern, pwaKitV3Pattern, storefrontNextPattern, sfraPattern, } from './patterns/index.js';
+// Utilities (for building custom patterns)
+export { readPackageJson, exists, glob, globDirs } from './utils.js';
+//# sourceMappingURL=index.js.map

package/dist/cjs/discovery/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/discovery/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AAEH,WAAW;AACX,OAAO,EAAC,qBAAqB,EAAE,mBAAmB,EAAC,MAAM,eAAe,CAAC;AAKzE,+BAA+B;AAC/B,OAAO,EACL,gBAAgB,EAChB,iBAAiB,EACjB,eAAe,EACf,qBAAqB,EACrB,WAAW,GACZ,MAAM,qBAAqB,CAAC;AAE7B,2CAA2C;AAC3C,OAAO,EAAC,eAAe,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAC,MAAM,YAAY,CAAC"}

package/dist/cjs/discovery/patterns/cartridges.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Cartridge project detection pattern.
+ *
+ * Detects any project containing cartridges by looking for .project files
+ * (Eclipse project markers used in SFCC development).
+ *
+ * @module discovery/patterns/cartridges
+ */
+import type { DetectionPattern } from '../types.js';
+/**
+ * Detection pattern for cartridge-based projects.
+ *
+ * Uses the SDK's findCartridges function to detect any cartridges in the workspace.
+ * This covers SFRA, custom APIs, and any other cartridge-based development.
+ */
+export declare const cartridgesPattern: DetectionPattern;