@splunk/splunk-ui-mcp 0.1.0 → 0.3.0

package/lib/resources/design-tokens.d.ts

@@ -0,0 +1,17 @@
+import { ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { ResourceLink, ReadResourceResult } from '@modelcontextprotocol/sdk/types.js';
+export declare const DESIGN_TOKEN_RESOURCE_NAME = "splunk-ui-design-tokens";
+export declare const DESIGN_TOKEN_RESOURCE_URI_BASE = "mcp://splunk-ui/design-tokens";
+export declare const createDesignTokenResourceUri: (tokenName: string) => string;
+export declare const createDesignTokenResourceLink: (tokenName: string) => ResourceLink;
+declare const designTokenResource: {
+    name: string;
+    template: ResourceTemplate;
+    config: {
+        title: string;
+        description: string;
+        mimeType: string;
+    };
+    handler: (uri: URL, params: Record<string, unknown>) => ReadResourceResult;
+};
+export default designTokenResource;

package/lib/resources/design-tokens.js

@@ -0,0 +1,115 @@
+import { ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { filterByKeywords, stringToKeywords } from '@splunk/ui-utils/filter.js';
+import { extractReplacementTokenName, getDesignTokenInfo, getDesignTokenList, } from "../utils/design-token-catalog.js";
+export const DESIGN_TOKEN_RESOURCE_NAME = 'splunk-ui-design-tokens';
+export const DESIGN_TOKEN_RESOURCE_URI_BASE = 'mcp://splunk-ui/design-tokens';
+export const createDesignTokenResourceUri = (tokenName) => `${DESIGN_TOKEN_RESOURCE_URI_BASE}/${encodeURIComponent(tokenName)}`;
+const createDesignTokenResourceMetadata = (tokenName) => {
+    return {
+        name: tokenName,
+        title: tokenName,
+        uri: createDesignTokenResourceUri(tokenName),
+        description: getDesignTokenInfo(tokenName)?.description,
+        mimeType: 'application/json',
+    };
+};
+export const createDesignTokenResourceLink = (tokenName) => ({
+    type: 'resource_link',
+    ...createDesignTokenResourceMetadata(tokenName),
+});
+const createDesignTokenResourcePayload = (token) => {
+    const replacementToken = extractReplacementTokenName(token.deprecated);
+    return {
+        name: token.name,
+        description: token.description,
+        type: token.type,
+        deprecated: token.deprecated,
+        usage: `variables.${token.name}`,
+        replacementToken,
+        replacementUsage: replacementToken ? `variables.${replacementToken}` : undefined,
+        cssProperties: token.cssProperties,
+        figmaVariableScopes: token.figmaVariableScopes,
+    };
+};
+const createListResult = () => ({
+    resources: getDesignTokenList().map((token) => ({
+        name: token.name,
+        title: token.name,
+        uri: createDesignTokenResourceUri(token.name),
+        description: token.description,
+        mimeType: 'application/json',
+    })),
+});
+const readDesignTokenResource = (tokenName) => {
+    const token = getDesignTokenInfo(tokenName);
+    if (!token) {
+        throw new Error(`Unknown design token "${tokenName}"`);
+    }
+    const resourcePayload = createDesignTokenResourcePayload(token);
+    return {
+        contents: [
+            {
+                uri: createDesignTokenResourceUri(token.name),
+                mimeType: 'application/json',
+                text: `${JSON.stringify(resourcePayload, null, 2)}\n`,
+            },
+        ],
+    };
+};
+const designTokenResourceTemplate = new ResourceTemplate(`${DESIGN_TOKEN_RESOURCE_URI_BASE}/{tokenName}`, {
+    list: async () => createListResult(),
+    complete: {
+        tokenName: async (value) => {
+            const input = value?.toString() ?? '';
+            const tokenNames = getDesignTokenList().map((token) => token.name);
+            if (!input) {
+                return tokenNames.slice(0, 50);
+            }
+            if (stringToKeywords(input).filter(Boolean).length === 0) {
+                return [];
+            }
+            return filterByKeywords(tokenNames, input).slice(0, 50);
+        },
+    },
+});
+const designTokenResource = {
+    name: DESIGN_TOKEN_RESOURCE_NAME,
+    template: designTokenResourceTemplate,
+    config: {
+        title: 'Splunk UI Design Tokens',
+        description: 'Metadata and usage guidance for design tokens from @splunk/themes.',
+        mimeType: 'application/json',
+    },
+    handler: (uri, params) => {
+        const { tokenName: tokenNameParam } = params;
+        let tokenName;
+        if (typeof tokenNameParam === 'string' && tokenNameParam.length > 0) {
+            try {
+                tokenName = decodeURIComponent(tokenNameParam);
+            }
+            catch {
+                throw new Error(`Invalid design token name in resource params: ${tokenNameParam}`);
+            }
+        }
+        else {
+            const pathParts = uri.pathname.split('/').filter(Boolean);
+            const encodedTokenName = pathParts[pathParts.length - 1];
+            if (encodedTokenName === 'design-tokens') {
+                tokenName = undefined;
+            }
+            else if (encodedTokenName) {
+                try {
+                    tokenName = decodeURIComponent(encodedTokenName);
+                }
+                catch {
+                    throw new Error(`Invalid design token name in resource path: ${encodedTokenName}`);
+                }
+            }
+        }
+        if (!tokenName) {
+            throw new Error(`Design token name missing in resource request: ${uri.toString()}`);
+        }
+        return readDesignTokenResource(tokenName);
+    },
+};
+export default designTokenResource;

package/lib/tools/find_component.d.ts

@@ -0,0 +1,19 @@
+import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+export declare const findComponentHandler: ({ query }: {
+    query?: string;
+}) => CallToolResult;
+declare const findComponentTool: {
+    name: string;
+    config: {
+        title: string;
+        description: string;
+        inputSchema: {
+            query: z.ZodString;
+        };
+    };
+    handler: ({ query }: {
+        query?: string;
+    }) => CallToolResult;
+};
+export default findComponentTool;

package/lib/tools/find_component.js

@@ -0,0 +1,93 @@
+import { z } from 'zod';
+import { createComponentResourceLink } from "../resources/components.js";
+import { getComponentDocs, getComponentInfo, getComponentNames, searchComponents, } from "../utils/component-catalog.js";
+const MAX_SUGGESTIONS = 5;
+const MAX_EXAMPLES = 10;
+const CATEGORY_SEARCH_MIN_QUERY_LENGTH = 3;
+const getSuggestedComponents = (trimmedQuery) => {
+    const includeCategory = trimmedQuery.length >= CATEGORY_SEARCH_MIN_QUERY_LENGTH;
+    return searchComponents(trimmedQuery, {
+        includeCategory,
+        limit: MAX_SUGGESTIONS,
+    });
+};
+export const findComponentHandler = ({ query }) => {
+    if (!query || query.trim().length === 0) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: 'Component query is required. Provide a component name or keywords.',
+                },
+            ],
+            isError: true,
+        };
+    }
+    const normalizedQuery = query.trim();
+    const componentInfo = getComponentInfo(normalizedQuery);
+    if (componentInfo) {
+        try {
+            const docs = getComponentDocs(componentInfo.name);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: docs,
+                    },
+                    createComponentResourceLink(componentInfo.name),
+                ],
+                structuredContent: {
+                    query: normalizedQuery,
+                    resultType: 'exact',
+                    component: componentInfo.name,
+                },
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to retrieve documentation for "${componentInfo.name}": ${error.message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    const suggestions = getSuggestedComponents(normalizedQuery);
+    const sampleNames = getComponentNames().slice(0, MAX_EXAMPLES).join(', ');
+    const hasSuggestions = suggestions.length > 0;
+    const suggestionText = hasSuggestions
+        ? `Top matches: ${suggestions.join(', ')}.\n\nUse one of the resource links below to open docs directly.`
+        : `No close matches found.\n\nAvailable components include: ${sampleNames}, and more.`;
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `No exact component match for "${normalizedQuery}".\n\n${suggestionText}`,
+            },
+            ...suggestions.map((name) => createComponentResourceLink(name)),
+        ],
+        structuredContent: {
+            query: normalizedQuery,
+            resultType: 'suggestions',
+            suggestions,
+        },
+    };
+};
+const findComponentTool = {
+    name: 'find_component',
+    config: {
+        title: 'Find Component Documentation',
+        description: 'Finds @splunk/react-ui components by exact name or fuzzy query. ' +
+            'Returns full docs for exact matches and ranked suggestions for discovery queries.',
+        inputSchema: {
+            query: z
+                .string()
+                .describe('Component name or keywords (e.g., "Button", "CardLayout", "table", "form rows").'),
+        },
+    },
+    handler: findComponentHandler,
+};
+export default findComponentTool;

package/lib/tools/find_design_token.d.ts

@@ -0,0 +1,16 @@
+import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+declare const findDesignTokenTool: {
+    name: string;
+    config: {
+        title: string;
+        description: string;
+        inputSchema: {
+            query: z.ZodString;
+        };
+    };
+    handler: ({ query }: {
+        query?: string;
+    }) => CallToolResult;
+};
+export default findDesignTokenTool;

package/lib/tools/find_design_token.js

@@ -0,0 +1,134 @@
+import { z } from 'zod';
+import { createDesignTokenResourceLink, createDesignTokenResourceUri, } from "../resources/design-tokens.js";
+import { extractReplacementTokenName, findDesignTokens, getDesignTokenInfo, isDeprecatedToken, } from "../utils/design-token-catalog.js";
+const NO_RESULTS_RESULT = {
+    content: [
+        {
+            type: 'text',
+            text: 'No design tokens found. Try keywords like "text", "background", "border", ' +
+                '"spacing", or "shadow".',
+        },
+    ],
+};
+const getReplacementToken = (token) => {
+    if (!token || !isDeprecatedToken(token)) {
+        return undefined;
+    }
+    const replacementTokenName = extractReplacementTokenName(token.deprecated);
+    return replacementTokenName ? getDesignTokenInfo(replacementTokenName) : undefined;
+};
+const addUsageReference = (token) => ({
+    name: token.name,
+    description: token.description,
+    type: token.type,
+    deprecated: token.deprecated,
+    usage: `variables.${token.name}`,
+    cssProperties: token.cssProperties,
+    figmaVariableScopes: token.figmaVariableScopes,
+});
+const formatTokenDetails = (token, options = {}) => {
+    const lines = [];
+    if (token.description) {
+        lines.push(`- Description: ${token.description}`);
+    }
+    if (token.type) {
+        lines.push(`- Type: \`${token.type}\``);
+    }
+    lines.push(`- Usage: \`variables.${token.name}\``);
+    if (token.cssProperties?.length) {
+        lines.push(`- CSS properties: ${token.cssProperties.map((p) => `\`${p}\``).join(', ')}`);
+    }
+    if (token.figmaVariableScopes?.length) {
+        lines.push(`- Figma variable scopes: ${token.figmaVariableScopes.map((p) => `\`${p}\``).join(', ')}`);
+    }
+    if (isDeprecatedToken(token)) {
+        lines.push(options.deprecatedAsBoolean
+            ? '- Deprecated: true'
+            : `- Deprecated: ${String(token.deprecated)}`);
+    }
+    const resourceLabel = options.resourceLabel ?? 'Resource';
+    lines.push(`- ${resourceLabel}: \`${createDesignTokenResourceUri(token.name)}\``);
+    return lines.join('\n');
+};
+const findDesignTokenHandler = ({ query }) => {
+    const normalizedQuery = query?.trim() ?? '';
+    if (normalizedQuery.length === 0) {
+        return NO_RESULTS_RESULT;
+    }
+    const exactMatch = getDesignTokenInfo(normalizedQuery);
+    const deprecatedExactMatch = exactMatch && isDeprecatedToken(exactMatch) ? exactMatch : undefined;
+    const exactReplacement = deprecatedExactMatch
+        ? getReplacementToken(deprecatedExactMatch)
+        : undefined;
+    const searchResults = exactMatch ? [] : findDesignTokens(normalizedQuery);
+    if (!exactMatch && searchResults.length === 0) {
+        return NO_RESULTS_RESULT;
+    }
+    let results = searchResults;
+    if (exactReplacement) {
+        results = [exactReplacement];
+    }
+    else if (exactMatch) {
+        results = [exactMatch];
+    }
+    const [recommended, ...others] = results;
+    const alternativeTokens = others.slice(0, 4);
+    const summarySections = [];
+    if (exactMatch && !deprecatedExactMatch) {
+        summarySections.push(`# \`${exactMatch.name}\``, formatTokenDetails(recommended, { resourceLabel: 'Resource link' }), 'Follow the resource links below for full token metadata.');
+    }
+    else if (deprecatedExactMatch && !exactReplacement) {
+        const deprecatedGuidance = typeof deprecatedExactMatch.deprecated === 'string'
+            ? `Query matched deprecated token \`${deprecatedExactMatch.name}\`. ${deprecatedExactMatch.deprecated}`
+            : `Query matched deprecated token \`${deprecatedExactMatch.name}\`. No replacement recommendation is available from token metadata.`;
+        summarySections.push(`# \`${deprecatedExactMatch.name}\``, deprecatedGuidance, formatTokenDetails(recommended, { deprecatedAsBoolean: true }), 'Follow the resource links below for full token metadata.');
+    }
+    else if (deprecatedExactMatch && exactReplacement) {
+        const deprecatedGuidance = typeof deprecatedExactMatch.deprecated === 'string'
+            ? `Query matched deprecated token \`${deprecatedExactMatch.name}\`. ${deprecatedExactMatch.deprecated}`
+            : `Query matched deprecated token \`${deprecatedExactMatch.name}\`.`;
+        summarySections.push(`# \`${deprecatedExactMatch.name}\``, deprecatedGuidance, '## Recommended Token', `Recommended to use \`${recommended.name}\` for "${normalizedQuery}"`, formatTokenDetails(recommended), 'Follow the resource links below for full token metadata.');
+    }
+    else {
+        summarySections.push(`# Design Tokens for "${normalizedQuery}"`, '## Recommended Token', `Recommended to use \`${recommended.name}\` for "${normalizedQuery}"`, formatTokenDetails(recommended), 'Follow the resource links below for full token metadata.');
+    }
+    if (alternativeTokens.length > 0) {
+        summarySections.push('## Alternative Tokens', alternativeTokens
+            .map((token) => `- \`${token.name}\`${token.description ? `: ${token.description}` : ''}`)
+            .join('\n'));
+    }
+    return {
+        content: [
+            {
+                type: 'text',
+                text: summarySections.join('\n\n'),
+            },
+            createDesignTokenResourceLink(recommended.name),
+            ...alternativeTokens.map((token) => createDesignTokenResourceLink(token.name)),
+        ],
+        structuredContent: {
+            recommended: addUsageReference(getDesignTokenInfo(recommended.name) ?? recommended),
+            alternatives: alternativeTokens
+                .map((token) => getDesignTokenInfo(token.name) ?? token)
+                .filter((token) => !isDeprecatedToken(token))
+                .map((token) => addUsageReference(token)),
+        },
+    };
+};
+const findDesignTokenTool = {
+    name: 'find_design_token',
+    config: {
+        title: 'Find Design Tokens',
+        description: 'Search for a Splunk UI design token from @splunk/themes. ' +
+            'In Splunk UI projects, all styling must use styled-components and design tokens for CSS properties as much as possible — ' +
+            'never hardcode hex values, rgb(), or CSS custom properties like var(--something). ' +
+            'Call this tool whenever you need a color, spacing, typography, shadow, or z-index value.',
+        inputSchema: {
+            query: z
+                .string()
+                .describe('What you are trying to style, e.g. "button background", "paragraph text color", "input border", "modal background", "spacing between elements", "focus shadow".'),
+        },
+    },
+    handler: findDesignTokenHandler,
+};
+export default findDesignTokenTool;

package/lib/tools/{find_icons.d.ts → find_icon.d.ts}

@@ -1,6 +1,6 @@
 import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
 import { z } from 'zod';
-declare const findIconsTool: {
+declare const findIconTool: {
     name: string;
     config: {
         title: string;
@@ -13,4 +13,4 @@ declare const findIconsTool: {
         query?: string;
     }) => CallToolResult;
 };
-export default findIconsTool;
+export default findIconTool;

package/lib/tools/{find_icons.js → find_icon.js}

@@ -30,7 +30,7 @@ const formatIconDetails = (details) => {
     lines.push(details.usageExample);
     return lines.join('\n');
 };
-const findIconsHandler = ({ query }) => {
+const findIconHandler = ({ query }) => {
     if (!query || query.trim().length === 0) {
         return NO_RESULTS_RESULT;
     }
@@ -86,8 +86,8 @@ const findIconsHandler = ({ query }) => {
         structuredContent,
     };
 };
-const findIconsTool = {
-    name: 'find_icons',
+const findIconTool = {
+    name: 'find_icon',
     config: {
         title: 'Find Icons',
         description: 'Search @splunk/react-icons for the best match and a few alternatives based on your keyword.',
@@ -97,6 +97,6 @@ const findIconsTool = {
                 .describe('The search query for the icon, e.g., "search", "notification", "user".'),
         },
     },
-    handler: findIconsHandler,
+    handler: findIconHandler,
 };
-export default findIconsTool;
+export default findIconTool;

package/lib/utils/component-catalog.d.ts

@@ -8,14 +8,30 @@ export type ComponentInfo = {
  * @internal
  */
 export declare function setDocsLlmPath(path: string | null): void;
+/**
+ * Normalizes component names for case-insensitive and format-insensitive matching.
+ * Examples:
+ * - "Card Layout" -> "cardlayout"
+ * - "CardLayout" -> "cardlayout"
+ * - "card-layout" -> "cardlayout"
+ */
+export declare function normalizeComponentName(name: string): string;
 /**
  * Returns the cached list of all components
  */
 export declare function getComponentList(): ComponentInfo[];
 /**
- * Checks if a component exists in the catalog
+ * Returns the cached list of component names
+ */
+export declare function getComponentNames(): string[];
+type SearchComponentsOptions = {
+    includeCategory?: boolean;
+    limit?: number;
+};
+/**
+ * Finds components by keyword and normalized substring matching.
  */
-export declare function componentExists(componentName: string): boolean;
+export declare function searchComponents(query: string, { limit, includeCategory }?: SearchComponentsOptions): string[];
 /**
  * Gets component info by name
  */
@@ -24,3 +40,4 @@ export declare function getComponentInfo(componentName: string): ComponentInfo |
  * Reads the markdown documentation for a component
  */
 export declare function getComponentDocs(componentName: string): string;
+export {};

package/lib/utils/component-catalog.js

@@ -1,7 +1,11 @@
 import { readFileSync } from 'fs';
-import { join, dirname, resolve, relative, isAbsolute } from 'path';
-import { createRequire } from 'module';
+import { join, resolve, relative, isAbsolute } from 'path';
+import { filterByKeywords } from '@splunk/ui-utils/filter.js';
+import { resolvePackageAssetPath } from "./package-assets.js";
 let componentCache = null;
+let componentNameCache = null;
+let componentInfoByNormalizedNameCache = null;
+let componentSearchIndexCache = null;
 let docsLlmPath = null;
 /**
  * Override the docs-llm path (primarily for testing)
@@ -10,15 +14,31 @@ let docsLlmPath = null;
 export function setDocsLlmPath(path) {
     docsLlmPath = path;
     componentCache = null; // Clear cache when path changes
+    componentNameCache = null;
+    componentInfoByNormalizedNameCache = null;
+    componentSearchIndexCache = null;
 }
 /**
  * Sanitizes component names; Rejects names containing path separators or parent directory references
  */
 function sanitizeComponentName(name) {
-    if (name.includes('/') || name.includes('\\') || name.includes('..')) {
+    const sanitizedName = name.trim();
+    if (sanitizedName.includes('/') ||
+        sanitizedName.includes('\\') ||
+        sanitizedName.includes('..')) {
         throw new Error(`Invalid component name: "${name}".`);
     }
-    return name;
+    return sanitizedName;
+}
+/**
+ * Normalizes component names for case-insensitive and format-insensitive matching.
+ * Examples:
+ * - "Card Layout" -> "cardlayout"
+ * - "CardLayout" -> "cardlayout"
+ * - "card-layout" -> "cardlayout"
+ */
+export function normalizeComponentName(name) {
+    return name.toLowerCase().replace(/[^a-z0-9]/g, '');
 }
 /**
  * Resolves the path to the @splunk/react-ui/docs-llm directory
@@ -31,23 +51,8 @@ function resolveDocsLlmPath() {
     if (docsLlmPath) {
         return docsLlmPath;
     }
-    // Try resolving from the user's project first
-    try {
-        const require = createRequire(join(process.cwd(), 'package.json'));
-        const reactUiPackagePath = require.resolve('@splunk/react-ui/package.json');
-        const reactUiPath = dirname(reactUiPackagePath);
-        docsLlmPath = join(reactUiPath, 'docs-llm');
-        return docsLlmPath;
-    }
-    catch {
-        // Project doesn't have @splunk/react-ui installed, fall back to MCP's bundled version
-    }
-    // Fall back to MCP's bundled version (for standalone usage via setup tool)
     try {
-        const require = createRequire(import.meta.url);
-        const reactUiPackagePath = require.resolve('@splunk/react-ui/package.json');
-        const reactUiPath = dirname(reactUiPackagePath);
-        docsLlmPath = join(reactUiPath, 'docs-llm');
+        docsLlmPath = resolvePackageAssetPath('@splunk/react-ui', 'docs-llm');
         return docsLlmPath;
     }
     catch (error) {
@@ -93,24 +98,67 @@ function parseComponentCatalog() {
  * Returns the cached list of all components
  */
 export function getComponentList() {
-    if (!componentCache) {
-        componentCache = parseComponentCatalog();
-    }
+    componentCache ??= parseComponentCatalog();
     return componentCache;
 }
 /**
- * Checks if a component exists in the catalog
+ * Returns the cached list of component names
  */
-export function componentExists(componentName) {
-    const components = getComponentList();
-    return components.some((c) => c.name === componentName);
+export function getComponentNames() {
+    componentNameCache ??= getComponentList().map((component) => component.name);
+    return componentNameCache;
+}
+function getComponentInfoByNormalizedNameMap() {
+    componentInfoByNormalizedNameCache ??= new Map(getComponentList().map((component) => [normalizeComponentName(component.name), component]));
+    return componentInfoByNormalizedNameCache;
+}
+function getComponentSearchIndex() {
+    componentSearchIndexCache ??= getComponentList().map((component) => {
+        const nameSearchText = component.name;
+        const nameAndCategorySearchText = component.category
+            ? `${component.name} ${component.category}`
+            : component.name;
+        return {
+            component,
+            nameSearchText,
+            nameAndCategorySearchText,
+            normalizedNameSearchText: normalizeComponentName(nameSearchText),
+            normalizedNameAndCategorySearchText: normalizeComponentName(nameAndCategorySearchText),
+        };
+    });
+    return componentSearchIndexCache;
+}
+/**
+ * Finds components by keyword and normalized substring matching.
+ */
+export function searchComponents(query, { limit, includeCategory } = {}) {
+    const input = query.trim();
+    const normalizedInput = normalizeComponentName(input);
+    if (!normalizedInput) {
+        return [];
+    }
+    const searchIndex = getComponentSearchIndex();
+    const keywordMatches = filterByKeywords(searchIndex, input, (entry) => includeCategory ? entry.nameAndCategorySearchText : entry.nameSearchText).map((entry) => entry.component.name);
+    const normalizedMatches = searchIndex
+        .filter((entry) => (includeCategory
+        ? entry.normalizedNameAndCategorySearchText
+        : entry.normalizedNameSearchText).includes(normalizedInput))
+        .map((entry) => entry.component.name);
+    const uniqueMatches = [...new Set([...normalizedMatches, ...keywordMatches])];
+    if (limit && limit > 0) {
+        return uniqueMatches.slice(0, limit);
+    }
+    return uniqueMatches;
 }
 /**
  * Gets component info by name
  */
 export function getComponentInfo(componentName) {
-    const components = getComponentList();
-    return components.find((c) => c.name === componentName);
+    const normalizedInput = normalizeComponentName(componentName);
+    if (!normalizedInput) {
+        return undefined;
+    }
+    return getComponentInfoByNormalizedNameMap().get(normalizedInput);
 }
 /**
  * Reads the markdown documentation for a component

package/lib/utils/design-token-catalog.d.ts

@@ -0,0 +1,37 @@
+import type * as CSS from 'csstype';
+import type { VariableScope } from '@figma/plugin-typings/plugin-api-standalone';
+export type DesignTokenRecord = {
+    name: string;
+    description?: string;
+    type?: string;
+    deprecated?: boolean | string;
+    defaultValue: unknown;
+    overrideCount: number;
+    hasOverrides: boolean;
+    overridesByContext: Record<string, unknown>;
+    cssProperties?: Array<keyof CSS.Properties>;
+    figmaVariableScopes?: VariableScope[];
+};
+/**
+ * Override the tokens.json path (primarily for testing)
+ * @internal
+ */
+export declare function setTokensPath(path: string | null): void;
+/**
+ * Extracts the replacement token name from a deprecation message.
+ *
+ * Deprecation messages that include a replacement follow the format defined in
+ * `@splunk/themes` deprecated.ts: `Use \`replacementTokenName\``
+ * This format is also relied upon by `@splunk/eslint-plugin-splunk-ui` for auto-fixing.
+ */
+export declare function extractReplacementTokenName(deprecated: boolean | string | undefined): string | undefined;
+export declare function isDeprecatedToken(token: DesignTokenRecord): boolean;
+export declare function getDesignTokenList(): DesignTokenRecord[];
+export declare function getDesignTokenInfo(tokenName: string): DesignTokenRecord | undefined;
+/**
+ * Search for design tokens matching the given query.
+ *
+ * Never returns deprecated tokens — use `getDesignTokenInfo` for direct lookup by name
+ * if you need to retrieve a token regardless of its deprecation status.
+ */
+export declare function findDesignTokens(query: string): DesignTokenRecord[];