@salesforce/b2c-dx-mcp 0.4.4 → 0.4.6

package/dist/tools/storefrontnext/figma/generate-component/formatter.d.ts

@@ -0,0 +1,9 @@
+import type { ComponentAnalysisResult, GenerateComponentInput } from './index.js';
+/**
+ * Formats the component generation recommendation for AI/developer.
+ *
+ * @param analysis - Component analysis result with REUSE/EXTEND/CREATE decision
+ * @param input - Original generate-component input (component name, etc.)
+ * @returns Formatted markdown string with recommendation, key differences, suggested approach, and next steps
+ */
+export declare function formatRecommendation(analysis: ComponentAnalysisResult, input: GenerateComponentInput): string;

package/dist/tools/storefrontnext/figma/generate-component/formatter.js

@@ -0,0 +1,92 @@
+/*
+ * 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
+ */
+/**
+ * Formats the component generation recommendation for AI/developer.
+ *
+ * @param analysis - Component analysis result with REUSE/EXTEND/CREATE decision
+ * @param input - Original generate-component input (component name, etc.)
+ * @returns Formatted markdown string with recommendation, key differences, suggested approach, and next steps
+ */
+export function formatRecommendation(analysis, input) {
+    let output = '# Component Generation Recommendation\n\n';
+    // Decision and confidence
+    output += `**Decision:** ${analysis.action}\n`;
+    output += `**Confidence:** ${analysis.confidence}%\n\n`;
+    // Matched component (if any)
+    if (analysis.matchedComponent) {
+        output += `**Matched Component:**\n`;
+        output += `- \`${analysis.matchedComponent.name}\` at \`${analysis.matchedComponent.path}\`\n`;
+        output += `- Similarity: ${analysis.matchedComponent.similarity}%\n\n`;
+    }
+    // Recommendation
+    output += `**Recommendation:** ${analysis.recommendation}\n\n`;
+    // Key differences
+    if (analysis.differences && analysis.differences.length > 0) {
+        output += `**Key Differences:**\n`;
+        for (const [i, diff] of analysis.differences.entries()) {
+            output += `${i + 1}. ${diff}\n`;
+        }
+        output += '\n';
+    }
+    // Suggested approach
+    if (analysis.suggestedApproach) {
+        output += `## Suggested Approach\n\n${analysis.suggestedApproach}\n\n`;
+    }
+    // Next steps
+    output += formatNextSteps(analysis, input);
+    return output;
+}
+/**
+ * Formats next steps based on action type
+ */
+function formatNextSteps(analysis, input) {
+    let section = '## Next Steps\n\n';
+    switch (analysis.action) {
+        case 'CREATE': {
+            section += `Create new component: \`${input.componentName}\`\n\n`;
+            section += `**Implementation:**\n`;
+            section += `1. Create component file structure (index.tsx, types.ts if needed)\n`;
+            section += `2. Convert Figma code to StorefrontNext patterns:\n`;
+            section += `   - Use React Server Components by default (add 'use client' if needed)\n`;
+            section += `   - Replace inline styles with Tailwind classes\n`;
+            section += `   - Map colors/spacing to theme tokens\n`;
+            section += `   - Add proper TypeScript types and accessibility attributes\n`;
+            section += `3. Export component from index\n`;
+            if (analysis.matchedComponent) {
+                section += `4. Reference patterns from \`${analysis.matchedComponent.path}\` for consistency\n`;
+            }
+            section += '\n';
+            break;
+        }
+        case 'EXTEND': {
+            const strategy = analysis.extendStrategy || 'props';
+            section += `**Strategy:** ${strategy === 'props' ? 'Add new props' : strategy === 'variant' ? 'Add variant' : 'Composition'}\n\n`;
+            section += `1. Modify \`${analysis.matchedComponent?.path}\`\n`;
+            if (strategy === 'props') {
+                section += `2. Add new optional props to the interface\n`;
+                section += `3. Implement new prop behavior while maintaining backward compatibility\n`;
+            }
+            else if (strategy === 'variant') {
+                section += `2. Add new variant to existing variant definitions\n`;
+                section += `3. Apply variant styling using theme tokens\n`;
+            }
+            else {
+                section += `2. Create wrapper component that composes the base component\n`;
+                section += `3. Add additional elements/functionality in the wrapper\n`;
+            }
+            section += `4. Validate: ensure existing usages still work\n\n`;
+            break;
+        }
+        case 'REUSE': {
+            section += `Import and use \`${analysis.matchedComponent?.name}\` from \`${analysis.matchedComponent?.path}\`.\n`;
+            section += `Customize through props and Tailwind classes to match the Figma design.\n\n`;
+            break;
+        }
+    }
+    section += '**Confirm before proceeding with implementation.**\n';
+    return section;
+}
+//# sourceMappingURL=formatter.js.map

package/dist/tools/storefrontnext/figma/generate-component/index.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Generate component tool for Figma-to-component workflow.
+ *
+ * Analyzes Figma design and discovered components to recommend REUSE, EXTEND, or CREATE strategy.
+ *
+ * @module tools/storefrontnext/figma/generate-component
+ */
+import { z } from 'zod';
+import type { McpTool } from '../../../../utils/index.js';
+import type { Services } from '../../../../services.js';
+/**
+ * A component discovered in the codebase that may match the Figma design.
+ *
+ * @property {string} path - Absolute file path to the component
+ * @property {string} name - Component name
+ * @property {number} similarity - Similarity score (0-100)
+ * @property {'name'|'structure'|'visual'} matchType - Type of match: 'name', 'structure', or 'visual'
+ * @property {string} code - Full source code of the component
+ */
+export interface SimilarComponent {
+    path: string;
+    name: string;
+    similarity: number;
+    matchType: 'name' | 'structure' | 'visual';
+    code: string;
+}
+export declare const generateComponentSchema: z.ZodObject<{
+    figmaMetadata: z.ZodString;
+    figmaCode: z.ZodString;
+    componentName: z.ZodString;
+    discoveredComponents: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        name: z.ZodString;
+        similarity: z.ZodNumber;
+        matchType: z.ZodEnum<["name", "structure", "visual"]>;
+        code: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        code: string;
+        path: string;
+        similarity: number;
+        matchType: "name" | "structure" | "visual";
+    }, {
+        name: string;
+        code: string;
+        path: string;
+        similarity: number;
+        matchType: "name" | "structure" | "visual";
+    }>, "many">;
+    workspacePath: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    figmaMetadata: string;
+    figmaCode: string;
+    componentName: string;
+    discoveredComponents: {
+        name: string;
+        code: string;
+        path: string;
+        similarity: number;
+        matchType: "name" | "structure" | "visual";
+    }[];
+    workspacePath?: string | undefined;
+}, {
+    figmaMetadata: string;
+    figmaCode: string;
+    componentName: string;
+    discoveredComponents: {
+        name: string;
+        code: string;
+        path: string;
+        similarity: number;
+        matchType: "name" | "structure" | "visual";
+    }[];
+    workspacePath?: string | undefined;
+}>;
+export type GenerateComponentInput = z.infer<typeof generateComponentSchema>;
+/**
+ * Result of component analysis recommending REUSE, EXTEND, or CREATE.
+ *
+ * @property {'CREATE'|'EXTEND'|'REUSE'} action - Recommended action: 'CREATE', 'EXTEND', or 'REUSE'
+ * @property {number} confidence - Confidence score (0-100)
+ * @property {{path: string, name: string, similarity: number}} [matchedComponent] - Best-matching component (if action is REUSE or EXTEND)
+ * @property {string[]} [differences] - Key differences between Figma design and matched component
+ * @property {string} recommendation - Human-readable recommendation text
+ * @property {string} [suggestedApproach] - Implementation guidance
+ * @property {'composition'|'props'|'variant'} [extendStrategy] - Strategy for EXTEND: 'props', 'variant', or 'composition'
+ */
+export interface ComponentAnalysisResult {
+    action: 'CREATE' | 'EXTEND' | 'REUSE';
+    confidence: number;
+    matchedComponent?: {
+        path: string;
+        name: string;
+        similarity: number;
+    };
+    differences?: string[];
+    recommendation: string;
+    suggestedApproach?: string;
+    extendStrategy?: 'composition' | 'props' | 'variant';
+}
+/**
+ * Generates a component recommendation from Figma design and discovered components.
+ *
+ * @param input - Figma design data (metadata, code), component name, and discovered components
+ * @returns Formatted recommendation with REUSE/EXTEND/CREATE decision and implementation guidance, or error message on failure
+ */
+export declare function generateComponentRecommendation(input: GenerateComponentInput): string;
+/**
+ * Creates the storefront_next_generate_component MCP tool.
+ *
+ * @param loadServices - Function that loads configuration and returns Services instance
+ * @returns MCP tool for component analysis and recommendation
+ */
+export declare function createGenerateComponentTool(loadServices: () => Services): McpTool;

package/dist/tools/storefrontnext/figma/generate-component/index.js

@@ -0,0 +1,98 @@
+/*
+ * 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 component tool for Figma-to-component workflow.
+ *
+ * Analyzes Figma design and discovered components to recommend REUSE, EXTEND, or CREATE strategy.
+ *
+ * @module tools/storefrontnext/figma/generate-component
+ */
+import { z } from 'zod';
+import { createToolAdapter, textResult } from '../../../adapter.js';
+import { analyzeComponentDifferences, determineAction } from './decision.js';
+import { formatRecommendation } from './formatter.js';
+const discoveredComponentSchema = z.object({
+    path: z.string().describe('Absolute file path to the component'),
+    name: z.string().describe('Component name'),
+    similarity: z.number().min(0).max(100).describe('Similarity score (0-100)'),
+    matchType: z.enum(['name', 'structure', 'visual']).describe('Type of match found'),
+    code: z.string().describe('Full source code of the component'),
+});
+export const generateComponentSchema = z
+    .object({
+    figmaMetadata: z.string().describe('JSON string containing Figma design metadata (from mcp__figma__get_metadata)'),
+    figmaCode: z.string().describe('Generated React code from Figma (from mcp__figma__get_design_context)'),
+    componentName: z.string().describe('Suggested name for the component extracted from Figma design'),
+    discoveredComponents: z
+        .array(discoveredComponentSchema)
+        .describe('Array of similar components discovered using Glob/Grep/Read. Pass empty array if no similar components found.'),
+    workspacePath: z
+        .string()
+        .optional()
+        .describe('Optional workspace root path. Defaults to the MCP server project directory.'),
+})
+    .strict();
+function analyzeComponent(input) {
+    const similarComponents = input.discoveredComponents;
+    if (similarComponents.length === 0) {
+        return {
+            action: 'CREATE',
+            confidence: 95,
+            recommendation: `No similar components found in the codebase. Will create new component: ${input.componentName}`,
+            suggestedApproach: 'Create a new component following StorefrontNext patterns.',
+        };
+    }
+    const topMatch = similarComponents[0];
+    const differences = analyzeComponentDifferences(topMatch, input.figmaCode, input.figmaMetadata);
+    const decision = determineAction(topMatch, differences);
+    return decision;
+}
+/**
+ * Generates a component recommendation from Figma design and discovered components.
+ *
+ * @param input - Figma design data (metadata, code), component name, and discovered components
+ * @returns Formatted recommendation with REUSE/EXTEND/CREATE decision and implementation guidance, or error message on failure
+ */
+export function generateComponentRecommendation(input) {
+    try {
+        const analysis = analyzeComponent(input);
+        const recommendation = formatRecommendation(analysis, input);
+        return recommendation;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return `# Error: Component Generation Failed\n\n${errorMessage}\n\nPlease check the input parameters and try again.`;
+    }
+}
+/**
+ * Creates the storefront_next_generate_component MCP tool.
+ *
+ * @param loadServices - Function that loads configuration and returns Services instance
+ * @returns MCP tool for component analysis and recommendation
+ */
+export function createGenerateComponentTool(loadServices) {
+    return createToolAdapter({
+        name: 'storefront_next_generate_component',
+        description: 'Analyzes Figma design and discovered components to recommend component generation strategy. ' +
+            'Workflow: 1) Discover similar components using Glob/Grep/Read tools, ' +
+            '2) Call this tool with the discoveredComponents parameter, ' +
+            '3) Tool analyzes differences and recommends REUSE/EXTEND/CREATE action, ' +
+            '4) Tool provides formatted recommendation with code examples and workflow steps. ' +
+            'Call this tool AFTER retrieving Figma design data and discovering similar components.',
+        toolsets: ['STOREFRONTNEXT'],
+        isGA: false,
+        requiresInstance: false,
+        inputSchema: generateComponentSchema.shape,
+        async execute(args, context) {
+            return generateComponentRecommendation({
+                ...args,
+                workspacePath: args.workspacePath ?? context.services.resolveWithProjectDirectory(),
+            });
+        },
+        formatOutput: (output) => textResult(output),
+    }, loadServices);
+}
+//# sourceMappingURL=index.js.map

package/dist/tools/storefrontnext/figma/map-tokens/css-parser.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Design token extracted from theme CSS (app.css).
+ *
+ * @property {string} name - CSS custom property name (e.g., "--color-primary")
+ * @property {string} value - Raw value (may be var() reference)
+ * @property {'dark'|'light'|'shared'} theme - Theme context: 'dark', 'light', or 'shared'
+ * @property {'color'|'fontFamily'|'fontSize'|'opacity'|'other'|'radius'|'spacing'} type - Token type for matching: color, spacing, radius, etc.
+ * @property {string} [resolvedValue] - Resolved value for var() references (actual hex/value)
+ */
+export interface ThemeToken {
+    name: string;
+    value: string;
+    theme: 'dark' | 'light' | 'shared';
+    type: 'color' | 'fontFamily' | 'fontSize' | 'opacity' | 'other' | 'radius' | 'spacing';
+    resolvedValue?: string;
+}
+/**
+ * Parsed theme file with tokens organized by theme context.
+ *
+ * @property {ThemeToken[]} tokens - All resolved tokens (excludes unresolved var() references)
+ * @property {Map<string,ThemeToken>} lightTokens - Map of token name to ThemeToken for light theme
+ * @property {Map<string,ThemeToken>} darkTokens - Map of token name to ThemeToken for dark theme
+ * @property {Map<string,ThemeToken>} sharedTokens - Map of token name to ThemeToken for shared tokens
+ * @property {string[]} warnings - Warnings (e.g., unresolved var() references)
+ */
+export interface ParsedTheme {
+    tokens: ThemeToken[];
+    lightTokens: Map<string, ThemeToken>;
+    darkTokens: Map<string, ThemeToken>;
+    sharedTokens: Map<string, ThemeToken>;
+    warnings: string[];
+}
+/**
+ * Finds the theme file path (app.css) in the workspace.
+ *
+ * @param workspaceRoot - Workspace root directory to search
+ * @returns Absolute path to app.css if found, or null
+ */
+export declare function findThemeFilePath(workspaceRoot?: string): null | string;
+/**
+ * Parses theme file and extracts all CSS custom properties.
+ *
+ * When themeFilePath is not provided, searches for app.css in src/app.css or app.css relative to workspaceRoot.
+ *
+ * @param themeFilePath - Optional absolute path to theme CSS file
+ * @param workspaceRoot - Optional workspace root for theme file discovery when themeFilePath is omitted
+ * @returns Parsed theme with tokens organized by light/dark/shared
+ * @throws {Error} When theme file is not found
+ */
+export declare function parseThemeFile(themeFilePath?: string, workspaceRoot?: string): ParsedTheme;
+/**
+ * Gets all color tokens from parsed theme.
+ *
+ * @param parsedTheme - Parsed theme from parseThemeFile
+ * @returns Array of color-type tokens
+ */
+export declare function getColorTokens(parsedTheme: ParsedTheme): ThemeToken[];
+/**
+ * Gets all spacing tokens from parsed theme.
+ *
+ * @param parsedTheme - Parsed theme from parseThemeFile
+ * @returns Array of spacing-type tokens
+ */
+export declare function getSpacingTokens(parsedTheme: ParsedTheme): ThemeToken[];
+/**
+ * Gets all radius tokens from parsed theme.
+ *
+ * @param parsedTheme - Parsed theme from parseThemeFile
+ * @returns Array of radius-type tokens
+ */
+export declare function getRadiusTokens(parsedTheme: ParsedTheme): ThemeToken[];

package/dist/tools/storefrontnext/figma/map-tokens/css-parser.js

@@ -0,0 +1,260 @@
+/*
+ * 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
+ */
+/**
+ * PostCSS dependency: Used to parse theme CSS (app.css) into an AST for reliable extraction of
+ * design tokens. Required for: (1) walking @theme at-rules and inline blocks, (2) distinguishing
+ * light/dark/shared tokens via selectors (e.g. [data-theme="light"], :root), (3) handling nested
+ * rules and var() references. Regex-based parsing would be brittle for real-world theme files.
+ */
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import postcss, {} from 'postcss';
+/**
+ * Determines the type of a CSS custom property based on its name and value
+ */
+function determineTokenType(name, value) {
+    const nameLower = name.toLowerCase();
+    if (nameLower.includes('color') || value.startsWith('#') || value.startsWith('rgb')) {
+        return 'color';
+    }
+    if (nameLower.includes('radius')) {
+        return 'radius';
+    }
+    if (nameLower.includes('opacity')) {
+        return 'opacity';
+    }
+    if (nameLower.includes('font-size') || nameLower.includes('text-size')) {
+        return 'fontSize';
+    }
+    if (nameLower.includes('font-family') || nameLower.includes('font-face')) {
+        return 'fontFamily';
+    }
+    if (nameLower.includes('spacing') ||
+        nameLower.includes('gap') ||
+        nameLower.includes('padding') ||
+        nameLower.includes('margin')) {
+        return 'spacing';
+    }
+    return 'other';
+}
+/**
+ * Extracts CSS custom property name from var() reference
+ * Example: "var(--primary)" -> "--primary"
+ */
+function extractVarName(value) {
+    const match = value.match(/var\(([^)]+)\)/);
+    return match ? match[1].trim() : null;
+}
+/**
+ * Resolves var() references to actual values
+ * Returns warnings for any unresolved references
+ */
+function resolveVarReferences(tokens) {
+    const warnings = [];
+    const tokenMap = new Map();
+    for (const token of tokens)
+        tokenMap.set(token.name, token);
+    for (const token of tokens) {
+        if (token.value.includes('var(')) {
+            const varName = extractVarName(token.value);
+            if (varName) {
+                const referencedToken = tokenMap.get(varName);
+                if (referencedToken) {
+                    // Recursively resolve if the referenced token also has a var()
+                    token.resolvedValue = referencedToken.resolvedValue || referencedToken.value;
+                }
+                else {
+                    // Unresolved reference - log warning and skip this token
+                    warnings.push(`Warning: Token "${token.name}" references undefined variable "${varName}". This token will be excluded from matching.`);
+                    // Don't set resolvedValue - this token will be filtered out
+                }
+            }
+        }
+        else {
+            token.resolvedValue = token.value;
+        }
+    }
+    return warnings;
+}
+/**
+ * Extracts custom properties from a PostCSS rule node
+ */
+function extractCustomPropertiesFromRule(rule, theme) {
+    const tokens = [];
+    rule.walkDecls((decl) => {
+        if (decl.prop.startsWith('--')) {
+            tokens.push({
+                name: decl.prop,
+                value: decl.value,
+                theme,
+                type: determineTokenType(decl.prop, decl.value),
+            });
+        }
+    });
+    return tokens;
+}
+/**
+ * Determines if a selector represents a dark theme context
+ */
+function isDarkThemeSelector(selector) {
+    return (selector.includes('.dark') ||
+        selector.includes('[data-theme="dark"]') ||
+        selector.includes("[data-theme='dark']") ||
+        (selector.includes('html:not(.dark)') && selector.includes('inverse')));
+}
+/**
+ * Determines if a selector represents a light theme context
+ */
+function isLightThemeSelector(selector) {
+    return (selector === ':root' ||
+        selector.includes('[data-theme="light"]') ||
+        selector.includes("[data-theme='light']") ||
+        (selector.includes('html.dark') && selector.includes('inverse')));
+}
+/**
+ * Parses CSS content to extract theme tokens from different sections using PostCSS
+ */
+function parseCSSContent(cssContent) {
+    const allTokens = [];
+    // Parse CSS with PostCSS
+    const root = postcss.parse(cssContent);
+    // Walk through all rules and at-rules
+    root.walkAtRules('theme', (atRule) => {
+        // Extract @theme inline block (shared tokens)
+        if (atRule.params.includes('inline')) {
+            atRule.walkDecls((decl) => {
+                if (decl.prop.startsWith('--')) {
+                    allTokens.push({
+                        name: decl.prop,
+                        value: decl.value,
+                        theme: 'shared',
+                        type: determineTokenType(decl.prop, decl.value),
+                    });
+                }
+            });
+        }
+    });
+    // Walk through all rules to find theme-specific tokens
+    root.walkRules((rule) => {
+        const selector = rule.selector;
+        // Determine theme based on selector
+        let theme = null;
+        if (isDarkThemeSelector(selector)) {
+            theme = 'dark';
+        }
+        else if (isLightThemeSelector(selector)) {
+            theme = 'light';
+        }
+        // Extract tokens if we identified a theme
+        if (theme) {
+            const tokens = extractCustomPropertiesFromRule(rule, theme);
+            allTokens.push(...tokens);
+        }
+    });
+    // Resolve var() references and collect warnings
+    const warnings = resolveVarReferences(allTokens);
+    // Filter out tokens with unresolved references
+    const resolvedTokens = allTokens.filter((token) => token.resolvedValue !== undefined);
+    // Log warnings about skipped tokens
+    if (warnings.length > 0 && resolvedTokens.length < allTokens.length) {
+        const skippedCount = allTokens.length - resolvedTokens.length;
+        warnings.push(`Skipped ${skippedCount} token(s) with unresolved var() references. These will not be available for matching.`);
+    }
+    // Organize tokens by theme
+    const lightTokens = new Map();
+    const darkTokens = new Map();
+    const sharedTokens = new Map();
+    for (const token of resolvedTokens) {
+        switch (token.theme) {
+            case 'dark': {
+                darkTokens.set(token.name, token);
+                break;
+            }
+            case 'light': {
+                lightTokens.set(token.name, token);
+                break;
+            }
+            case 'shared': {
+                sharedTokens.set(token.name, token);
+                break;
+            }
+        }
+    }
+    return {
+        tokens: resolvedTokens,
+        lightTokens,
+        darkTokens,
+        sharedTokens,
+        warnings,
+    };
+}
+/**
+ * Finds the theme file path (app.css) in the workspace.
+ *
+ * @param workspaceRoot - Workspace root directory to search
+ * @returns Absolute path to app.css if found, or null
+ */
+export function findThemeFilePath(workspaceRoot) {
+    if (!workspaceRoot) {
+        return null;
+    }
+    const possiblePaths = [join(workspaceRoot, 'src/app.css'), join(workspaceRoot, 'app.css')];
+    for (const path of possiblePaths) {
+        if (existsSync(path)) {
+            return path;
+        }
+    }
+    return null;
+}
+/**
+ * Parses theme file and extracts all CSS custom properties.
+ *
+ * When themeFilePath is not provided, searches for app.css in src/app.css or app.css relative to workspaceRoot.
+ *
+ * @param themeFilePath - Optional absolute path to theme CSS file
+ * @param workspaceRoot - Optional workspace root for theme file discovery when themeFilePath is omitted
+ * @returns Parsed theme with tokens organized by light/dark/shared
+ * @throws {Error} When theme file is not found
+ */
+export function parseThemeFile(themeFilePath, workspaceRoot) {
+    const filePath = themeFilePath ?? findThemeFilePath(workspaceRoot);
+    if (!filePath) {
+        throw new Error('Theme file (app.css) not found. Please provide the themeFilePath parameter.');
+    }
+    if (!existsSync(filePath)) {
+        throw new Error(`Theme file not found at: ${filePath}`);
+    }
+    const cssContent = readFileSync(filePath, 'utf8');
+    return parseCSSContent(cssContent);
+}
+/**
+ * Gets all color tokens from parsed theme.
+ *
+ * @param parsedTheme - Parsed theme from parseThemeFile
+ * @returns Array of color-type tokens
+ */
+export function getColorTokens(parsedTheme) {
+    return parsedTheme.tokens.filter((token) => token.type === 'color');
+}
+/**
+ * Gets all spacing tokens from parsed theme.
+ *
+ * @param parsedTheme - Parsed theme from parseThemeFile
+ * @returns Array of spacing-type tokens
+ */
+export function getSpacingTokens(parsedTheme) {
+    return parsedTheme.tokens.filter((token) => token.type === 'spacing');
+}
+/**
+ * Gets all radius tokens from parsed theme.
+ *
+ * @param parsedTheme - Parsed theme from parseThemeFile
+ * @returns Array of radius-type tokens
+ */
+export function getRadiusTokens(parsedTheme) {
+    return parsedTheme.tokens.filter((token) => token.type === 'radius');
+}
+//# sourceMappingURL=css-parser.js.map