@atlaskit/ads-mcp 0.18.0 → 0.19.0

package/dist/es2019/tools/migration-guides/index.js

@@ -8,14 +8,20 @@ import { getAvailableMigrationIds, getAvailableMigrationsDescription, migrationR
 const migrationIds = getAvailableMigrationIds();
 const migrationDescriptions = getAvailableMigrationsDescription();
 export const migrationGuidesInputSchema = z.object({
-  migration: z.enum(migrationIds).describe(`The specific migration to perform.\n`),
-  description: z.enum(migrationDescriptions).describe(`Description of the migration type.\n`)
+  migration: z.enum(migrationIds).describe('Migration id from the registry. Must match the guide you want (see tool description list).'),
+  description: z.enum(migrationDescriptions).describe('Human-readable migration label that pairs with `migration` in the schema—choose the entry that matches the selected id.')
 });
 export const listMigrationGuidesTool = {
   name: 'ads_migration_guides',
-  description: `Migration guides for Atlassian Design System components.
+  description: `Returns a structured Atlassian Design System (ADS) **migration guide** for a known package or API migration (before/after examples, best practices, links).
 
-	Available migrations:\n${getAvailableMigrationsDescription()}`,
+WHEN TO USE:
+You are upgrading or refactoring code between ADS packages or APIs and need the official migration pattern for a specific id listed below.
+
+Pass **both** \`migration\` and \`description\` using a **matching pair** from the enum (schema enforces valid combinations).
+
+Available migrations:
+${getAvailableMigrationsDescription()}`,
   annotations: {
     title: 'ADS Migration Guides',
     readOnlyHint: true,

package/dist/es2019/tools/plan/index.js

@@ -6,17 +6,25 @@ import { searchComponentsTool } from '../search-components';
 import { searchIconsTool } from '../search-icons';
 import { searchTokensTool } from '../search-tokens';
 export const planInputSchema = z.object({
-  tokens: z.array(z.string()).describe('Array of terms to search for tokens, eg. `["spacing", "inverted text", "background primary"]`. Provide a minimum of 2 terms when known.'),
-  icons: z.array(z.string()).describe('Array of terms to search for icons, eg. `["search", "folder", "user"]`. Provide a minimum of 2 terms when known.'),
-  components: z.array(z.string()).describe('Array of terms to search for components, eg. `["button", "input", "select"]`. Provide a minimum of 2 terms when known.'),
-  limit: z.number().default(1).describe('Maximum number of results per search term in the provided arrays (default: 1)').optional(),
-  exactName: z.boolean().default(false).describe('Search tokens, icons, and components by their exact name match (use when you explicitly know the name and need more details)').optional()
+  tokens: z.array(z.string()).describe('Search terms for ADS design tokens (fuzzy by default). Use `[]` if you only need icons or components. Prefer **at least two** terms per non-empty list when you know what you need.'),
+  icons: z.array(z.string()).describe('Search terms for ADS icons. Use `[]` if you only need tokens or components. Prefer **at least two** terms per non-empty list when known.'),
+  components: z.array(z.string()).describe('Search terms for ADS components. Use `[]` if you only need tokens or icons. Prefer **at least two** terms per non-empty list when known.'),
+  limit: z.number().default(2).describe('Max matches **per term** for each non-empty list (default 2). Same limit applies to tokens, icons, and components searches.').optional()
 });
 export const listPlanTool = {
   name: 'ads_plan',
-  description: `Search how to use the Atlassian Design System offerings and get guidance on \`tokens\`, \`icons\`, and \`components\`.
+  description: `Runs **ads_search_tokens**, **ads_search_icons**, and **ads_search_components** in one call and returns a single JSON payload (each section only if that list was non-empty). Use this as the default way to discover ADS **tokens**, **icons**, and **components** for a UI task.
 
-YOU MUST ALWAYS call this tool with known parameters and include a minimum of 2 search terms per parameter when known, eg.
+WHEN TO USE:
+**Implementing or iterating on a UI**—new screen, feature, or polish—and you need candidate **token** names, **icon** imports, and **component** packages/props in one pass. Also use when exploring ADS building blocks before you write code.
+
+At least one of \`tokens\`, \`icons\`, or \`components\` must contain search terms (use \`[]\` for lists you do not need).
+
+Prefer supplying **multiple** terms per non-empty array when you know them—broader queries improve recall. Some queries return no rows where metadata is thin; try alternate wording.
+
+This is equivalent to calling the individual search tools; there are no extra merge semantics beyond concatenating results.
+
+Example request:
 \`\`\`json
 {
 	"tokens": ["spacing", "inverted text", "background primary", "animation"],
@@ -25,8 +33,6 @@ YOU MUST ALWAYS call this tool with known parameters and include a minimum of 2
 }
 \`\`\`
 
-Please note, there may not be results for everything as there are minor gaps in offerings or how we describe them.
-
 Example token usage:
 \`\`\`tsx
 import { token } from '@atlaskit/tokens';
@@ -39,7 +45,7 @@ import AddIcon from '@atlaskit/icon/core/add';
 <AddIcon label="Add work item" size="small" />
 \`\`\``,
   annotations: {
-    title: 'Plan ADS resources',
+    title: 'Search ADS tokens, icons, and components to plan what to build',
     readOnlyHint: true,
     destructiveHint: false,
     idempotentHint: true,
@@ -47,15 +53,12 @@ import AddIcon from '@atlaskit/icon/core/add';
   },
   inputSchema: zodToJsonSchema(planInputSchema)
 };
-export const planTool = async params => {
-  const {
-    tokens: tokens_search,
-    icons: icons_search,
-    components: components_search,
-    limit = 1,
-    exactName = false
-  } = params;
-
+export const planTool = async ({
+  tokens: tokens_search,
+  icons: icons_search,
+  components: components_search,
+  limit
+}) => {
   // Validate that at least one search type is provided
   if (!(tokens_search !== null && tokens_search !== void 0 && tokens_search.length) && !(icons_search !== null && icons_search !== void 0 && icons_search.length) && !(components_search !== null && components_search !== void 0 && components_search.length)) {
     return {
@@ -73,8 +76,7 @@ export const planTool = async params => {
   if (tokens_search !== null && tokens_search !== void 0 && tokens_search.length) {
     searchPromises.push(searchTokensTool({
       terms: tokens_search,
-      limit,
-      exactName
+      limit
     }).then(result => {
       results.tokens = result;
     }));
@@ -82,8 +84,7 @@ export const planTool = async params => {
   if (icons_search !== null && icons_search !== void 0 && icons_search.length) {
     searchPromises.push(searchIconsTool({
       terms: icons_search,
-      limit,
-      exactName
+      limit
     }).then(result => {
       results.icons = result;
     }));
@@ -91,8 +92,7 @@ export const planTool = async params => {
   if (components_search !== null && components_search !== void 0 && components_search.length) {
     searchPromises.push(searchComponentsTool({
       terms: components_search,
-      limit,
-      exactName
+      limit
     }).then(result => {
       results.components = result;
     }));

package/dist/es2019/tools/search-components/index.js

@@ -2,16 +2,18 @@
 
 import Fuse from 'fuse.js';
 import { z } from 'zod';
-import { cleanQuery, zodToJsonSchema } from '../../helpers';
-import { loadAllComponents } from '../get-components/load-all-components';
+import { cleanQuery, mergeMultiTermFuseResults, zodToJsonSchema } from '../../helpers';
+import { loadAllComponents } from '../get-all-components/load-all-components';
 export const searchComponentsInputSchema = z.object({
-  terms: z.array(z.string()).describe('An array of search terms to find components by name, package name, description, or example, eg. `["button", "input", "select"]`'),
-  limit: z.number().default(1).describe('Maximum number of results per search term in the array (default: 1)').optional(),
-  exactName: z.boolean().default(false).describe('Enable to explicitly search components by the exact name match (when you know the name, but need more details)').optional()
+  terms: z.array(z.string()).describe('Required: one or more search terms (fuzzy over name, package, category, description, keywords, examples). Example: `["button", "modal", "select"]`.'),
+  limit: z.number().default(2).describe('Max matches **per term** (default 2).').optional()
 });
 export const listSearchComponentsTool = {
   name: 'ads_search_components',
-  description: 'Search for Atlassian Design System components.',
+  description: `Searches the bundled Atlassian Design System (ADS) component catalog. Returns JSON objects with **name**, **package**, **examples**, and **props** for each match (trimmed payload).
+
+WHEN TO USE:
+**Selecting which ADS component to use**—package name, examples, and props—before implementation. Use when composing a new view or swapping a primitive. Prefer \`ads_plan\` when you also need token and icon discovery in one shot.`,
   annotations: {
     title: 'Search ADS components',
     readOnlyHint: true,
@@ -21,9 +23,7 @@ export const listSearchComponentsTool = {
   },
   inputSchema: zodToJsonSchema(searchComponentsInputSchema)
 };
-
-// Clean component result to only return name, package name, example, and props
-const cleanComponentResult = result => {
+const buildComponentResult = result => {
   return {
     name: result.name,
     package: result.package,
@@ -31,43 +31,24 @@ const cleanComponentResult = result => {
     props: result.props
   };
 };
-export const searchComponentsTool = async params => {
-  const {
-    terms,
-    limit = 1,
-    exactName = false
-  } = params;
-  const searchTerms = terms.filter(Boolean).map(cleanQuery);
+export const searchComponentsTool = async ({
+  terms,
+  limit = 2
+}) => {
+  const searchTerms = [...new Set(terms.filter(Boolean).map(cleanQuery))];
   if (!searchTerms.length) {
     return {
-      isError: true,
       content: [{
         type: 'text',
-        text: `Error: Required parameter 'terms' is missing or empty`
+        text: '[]'
       }]
     };
   }
   const components = loadAllComponents();
-  if (exactName) {
-    // for each search term, search for the exact match
-    const exactNameMatches = searchTerms.map(term => {
-      return components.find(component => component.name.toLowerCase() === term.toLowerCase());
-    }).filter(Boolean);
-    if (exactNameMatches.length > 0) {
-      return {
-        content: [{
-          type: 'text',
-          text: JSON.stringify(exactNameMatches.map(cleanComponentResult))
-        }]
-      };
-    }
-  }
-
-  // use Fuse.js to fuzzy-search through the components
   const fuse = new Fuse(components, {
     keys: [{
       name: 'name',
-      weight: 3
+      weight: 5
     }, {
       name: 'package',
       weight: 3
@@ -77,42 +58,47 @@ export const searchComponentsTool = async params => {
     }, {
       name: 'description',
       weight: 2
+    }, {
+      name: 'keywords',
+      weight: 2
+    }, {
+      name: 'usageGuidelines',
+      weight: 2
+    }, {
+      name: 'contentGuidelines',
+      weight: 1
+    }, {
+      name: 'accessibilityGuidelines',
+      weight: 1
     }, {
       name: 'examples',
       weight: 1
     }],
-    threshold: 0.4
+    threshold: 0.4,
+    distance: 80,
+    minMatchCharLength: 3,
+    ignoreFieldNorm: true,
+    includeScore: true
   });
-
-  // every search term, search for the results
-  const results = searchTerms.map(term => {
-    // always search exact match from the components first
-    const exactNameMatch = components.find(component => component.name.toLowerCase() === term.toLowerCase());
-    if (exactNameMatch) {
-      return [{
-        item: exactNameMatch
-      }];
-    }
-    return fuse.search(term).slice(0, limit);
-  }).flat();
-  if (!results.length) {
+  const matchedItems = mergeMultiTermFuseResults({
+    searchTerms,
+    limit,
+    search: query => fuse.search(query, {
+      limit: limit * searchTerms.length
+    })
+  });
+  if (!matchedItems.length) {
     return {
-      isError: true,
       content: [{
         type: 'text',
         text: `Error: No components found for '${terms.join(', ')}'. Available components: ${components.map(c => c.name).join(', ')}`
       }]
     };
   }
-
-  // Remove duplicates based on component name
-  const uniqueResults = results.filter((result, index, arr) => {
-    return arr.findIndex(r => r.item.name === result.item.name) === index;
-  });
   return {
     content: [{
       type: 'text',
-      text: JSON.stringify(uniqueResults.map(result => result.item).map(cleanComponentResult))
+      text: JSON.stringify(matchedItems.map(buildComponentResult))
     }]
   };
 };

package/dist/es2019/tools/search-icons/index.js

@@ -2,18 +2,25 @@
 
 import Fuse from 'fuse.js';
 import { z } from 'zod';
-import { cleanQuery, zodToJsonSchema } from '../../helpers';
+import { cleanQuery, mergeMultiTermFuseResults, zodToJsonSchema } from '../../helpers';
 import { icons } from '../get-all-icons/icons';
 export const searchIconsInputSchema = z.object({
-  terms: z.array(z.string()).describe('An array of search terms to find icons by name, keywords, or categorization, eg. `["search", "folder", "user"]`'),
-  limit: z.number().default(1).describe('Maximum number of results per search term in the array (default: 1)').optional(),
-  exactName: z.boolean().default(false).describe('Enable to explicitly search icons by the exact name match (when you know the name, but need more details)').optional()
+  terms: z.array(z.string()).describe('Required: one or more terms; fuzzy match on icon **componentName**, **iconName**, **keywords**, **categorization**, **type**, and **usage**. Example: `["search", "folder", "user"]`.'),
+  limit: z.number().default(2).describe('Max matches **per term** (default 2).').optional()
+});
+const buildIconResult = icon => ({
+  componentName: icon.componentName,
+  package: icon.package,
+  usage: icon.usage
 });
 export const listSearchIconsTool = {
   name: 'ads_search_icons',
-  description: `Search for Atlassian Design System icons.
+  description: `Searches the bundled Atlassian Design System **icon** catalog. Returns JSON with **componentName**, **package**, and **usage** for each match.
+
+WHEN TO USE:
+**Choosing an icon** for a control, nav item, empty state, or illustration—find \`@atlaskit/icon\` import paths and usage notes. Prefer \`ads_plan\` when you also need tokens and components together.
 
-Example icon usage:
+Example:
 \`\`\`tsx
 import AddIcon from '@atlaskit/icon/core/add';
 <AddIcon label="Add work item" size="small" />
@@ -27,42 +34,23 @@ import AddIcon from '@atlaskit/icon/core/add';
   },
   inputSchema: zodToJsonSchema(searchIconsInputSchema)
 };
-export const searchIconsTool = async params => {
-  const {
-    terms,
-    limit = 1,
-    exactName = false
-  } = params;
-  const searchTerms = terms.filter(Boolean).map(cleanQuery);
+export const searchIconsTool = async ({
+  terms,
+  limit = 2
+}) => {
+  const searchTerms = [...new Set(terms.filter(Boolean).map(cleanQuery))];
   if (!searchTerms.length) {
     return {
-      isError: true,
       content: [{
         type: 'text',
-        text: `Error: Required parameter 'terms' is missing or empty`
+        text: '[]'
       }]
     };
   }
-  if (exactName) {
-    // for each search term, search for the exact match
-    const exactNameMatches = searchTerms.map(term => {
-      return icons.find(icon => icon.componentName.toLowerCase() === term.toLowerCase());
-    }).filter(Boolean);
-    if (exactNameMatches.length > 0) {
-      return {
-        content: [{
-          type: 'text',
-          text: JSON.stringify(exactNameMatches)
-        }]
-      };
-    }
-  }
-
-  // use Fuse.js to fuzzy-search through the icons
   const fuse = new Fuse(icons, {
     keys: [{
       name: 'componentName',
-      weight: 3
+      weight: 5
     }, {
       name: 'iconName',
       weight: 3
@@ -71,53 +59,40 @@ export const searchIconsTool = async params => {
       weight: 2
     }, {
       name: 'categorization',
-      weight: 1
+      weight: 2
     }, {
       name: 'type',
       weight: 1
     }, {
       name: 'usage',
-      weight: 1
+      weight: 2
     }],
-    threshold: 0.4
+    threshold: 0.4,
+    distance: 80,
+    minMatchCharLength: 3,
+    ignoreFieldNorm: true,
+    includeScore: true
   });
-
-  // every search term, search for the results
-  const results = searchTerms.map(term => {
-    // always search exact match from the icons
-    const exactNameMatch = icons.find(icon => icon.componentName.toLowerCase() === term.toLowerCase());
-    if (exactNameMatch) {
-      return [{
-        item: exactNameMatch
-      }];
-    }
-    return fuse.search(term).slice(0, limit);
-  }).flat();
-  if (!results.length) {
+  const matchedItems = mergeMultiTermFuseResults({
+    searchTerms,
+    limit,
+    search: query => fuse.search(query, {
+      limit: limit * searchTerms.length
+    }),
+    tokenKey: icon => icon.componentName
+  });
+  if (!matchedItems.length) {
     return {
-      isError: true,
       content: [{
         type: 'text',
         text: `Error: No icons found for '${terms.join(', ')}'. Available icons: ${icons.map(i => i.componentName).join(', ')}`
       }]
     };
   }
-
-  // Remove duplicates based on componentName
-  const uniqueResults = results.filter((result, index, arr) => {
-    return arr.findIndex(r => r.item.componentName === result.item.componentName) === index;
-  });
-  const matchedIcons = uniqueResults.map(result => {
-    return {
-      componentName: result.item.componentName,
-      package: result.item.package,
-      usage: result.item.usage
-    };
-  });
   return {
     content: [{
       type: 'text',
-      text: JSON.stringify(matchedIcons)
+      text: JSON.stringify(matchedItems.map(buildIconResult))
     }]
   };
 };

package/dist/es2019/tools/search-tokens/index.js

@@ -3,17 +3,19 @@
 import Fuse from 'fuse.js';
 import { z } from 'zod';
 import { tokens } from '@atlaskit/tokens/token-metadata';
-import { cleanQuery, zodToJsonSchema } from '../../helpers';
+import { cleanQuery, mergeMultiTermFuseResults, zodToJsonSchema } from '../../helpers';
 export const searchTokensInputSchema = z.object({
-  terms: z.array(z.string()).describe('An array of search terms to find tokens by name or description, eg. `["spacing", "inverted text", "background primary"]`'),
-  limit: z.number().default(1).describe('Maximum number of results per search term in the array (default: 1)').optional(),
-  exactName: z.boolean().default(false).describe('Enable to explicitly search tokens by the exact name match (when you know the name, but need more details)').optional()
+  terms: z.array(z.string()).describe('Required: one or more terms; fuzzy match on token **name**, **description**, **exampleValue**, **usageGuidelines.usage**, and **usageGuidelines.cssProperties**. Example: `["spacing", "color.text", "background"]`.'),
+  limit: z.number().default(2).describe('Max matches **per term** (default 2).').optional()
 });
 export const listSearchTokensTool = {
   name: 'ads_search_tokens',
-  description: `Search for Atlassian Design System tokens.
+  description: `Searches Atlassian Design System **design tokens** from bundled metadata. Returns JSON objects with **name** and **exampleValue** for each match (search also considers description, usage guidelines, and CSS property hints in metadata).
 
-Example token usage:
+WHEN TO USE:
+**Styling or theming in code**—you need the right \`token('…')\` names for colors, space, typography, etc. Use during layout and visual work when tokens must match ADS. Prefer \`ads_plan\` when you also need icons and components in the same step.
+
+Example:
 \`\`\`tsx
 import { token } from '@atlaskit/tokens';
 const styles = css({ color: token('color.text'), padding: token('space.100') });
@@ -27,59 +29,66 @@ const styles = css({ color: token('color.text'), padding: token('space.100') });
   },
   inputSchema: zodToJsonSchema(searchTokensInputSchema)
 };
-export const searchTokensTool = async params => {
-  const {
-    terms,
-    limit = 1,
-    exactName = false
-  } = params;
-  const searchTerms = terms.filter(Boolean).map(cleanQuery);
-  if (exactName) {
-    // for each search term, search for the exact match
-    const exactNameMatches = searchTerms.map(term => {
-      return tokens.find(token => token.name.toLowerCase() === term.toLowerCase());
-    }).filter(Boolean);
-    if (exactNameMatches.length > 0) {
-      return {
-        content: [{
-          type: 'text',
-          text: JSON.stringify(exactNameMatches.map(token => ({
-            name: token.name,
-            exampleValue: token.exampleValue
-          })))
-        }]
-      };
-    }
+export const searchTokensTool = async ({
+  terms,
+  limit = 2
+}) => {
+  // Unique cleaned terms (order preserved) so duplicates don't concatenate into a bogus query.
+  const searchTerms = [...new Set(terms.filter(Boolean).map(cleanQuery))];
+  if (!searchTerms.length) {
+    return {
+      content: [{
+        type: 'text',
+        text: '[]'
+      }]
+    };
   }
-
-  // use Fuse.js to fuzzy-search for the tokens
   const fuse = new Fuse(tokens, {
     keys: [{
       name: 'name',
-      weight: 3
+      weight: 5
+    }, {
+      name: 'path',
+      weight: 2
     }, {
       name: 'description',
       weight: 2
+    }, {
+      name: 'usageGuidelines.usage',
+      weight: 2
+    }, {
+      name: 'usageGuidelines.cssProperties',
+      weight: 3
     }, {
       name: 'exampleValue',
-      weight: 1
+      weight: 0.5
     }],
-    threshold: 0.4
+    threshold: 0.4,
+    distance: 80,
+    minMatchCharLength: 3,
+    ignoreFieldNorm: true,
+    includeScore: true
   });
-  const results = searchTerms.map(term => {
-    return fuse.search(term).slice(0, limit);
-  }).flat();
-
-  // Remove duplicates based on token name
-  const uniqueResults = results.filter((result, index, arr) => {
-    return arr.findIndex(r => r.item.name === result.item.name) === index;
+  const matchedItems = mergeMultiTermFuseResults({
+    searchTerms,
+    limit,
+    search: query => fuse.search(query, {
+      limit: limit * searchTerms.length
+    }),
+    searchTermsJoin: '.'
   });
-  const matchedTokens = uniqueResults.map(result => {
+  const matchedTokens = matchedItems.map(item => ({
+    name: item.name,
+    exampleValue: item.exampleValue
+  }));
+  if (!matchedTokens.length) {
     return {
-      name: result.item.name,
-      exampleValue: result.item.exampleValue
+      content: [{
+        type: 'text',
+        text: `Error: No tokens found for '${terms.join(', ')}'. Available tokens: ${tokens.map(t => t.name).join(', ')}`
+      }]
     };
-  });
+  }
   return {
     content: [{
       type: 'text',

package/dist/es2019/tools/suggest-a11y-fixes/index.js

@@ -5,16 +5,25 @@ import { zodToJsonSchema } from '../../helpers';
 import { accessibilityFixes } from './fixes';
 import { violationKeywords } from './keywords';
 export const suggestA11yFixesInputSchema = z.object({
-  violation: z.string().describe('Description of the accessibility violation'),
-  code: z.string().describe('The problematic code that needs fixing'),
-  component: z.string().optional().describe('Component name or type'),
-  context: z.string().optional().describe('Additional context about the usage')
+  violation: z.string().describe('Human-readable description of the issue (e.g. axe rule help text, "button has no accessible name", "missing alt"). Used to match curated recipes when possible; otherwise the tool falls back to generic guidance.'),
+  code: z.string().describe('Snippet of the problematic code or markup so the response can be tailored (may be shown in the output for traceability).'),
+  component: z.string().optional().describe('Optional: React component name involved (e.g. `Button`, `TextField`)—may be ADS or app-specific.'),
+  context: z.string().optional().describe('Optional: where this appears (e.g. modal, table row, page section) or constraints.')
 });
 export const listSuggestA11yFixesTool = {
   name: 'ads_suggest_a11y_fixes',
-  description: `Suggests specific accessibility fixes using Atlassian Design System components and patterns.`,
+  description: `Suggests remediation steps for an accessibility issue described in natural language (often pasted from **axe-core**, ESLint, or review).
+
+WHAT YOU GET (varies by match):
+- **Curated hit:** ADS-biased examples and patterns from this server’s recipe map (components, tokens, common fixes).
+- **No strong match:** Generic guidance (e.g. “use ADS components”, labeling, testing)—still useful, but **not** guaranteed to be ADS-specific. May reference axe/atlassian.design resources.
+
+WHEN TO USE:
+After \`ads_analyze_a11y\` or \`ads_analyze_localhost_a11y\`, or whenever you have a violation string. For **topic-level** Atlassian Design System accessibility guidance, call \`ads_get_a11y_guidelines\` (this tool is fix-oriented, not a full guideline browse).
+
+Does not replace manual testing with assistive technologies or keyboard-only navigation.`,
   annotations: {
-    title: 'Suggest Accessibility Fixes',
+    title: 'Suggest accessibility fixes',
     readOnlyHint: true,
     destructiveHint: false,
     idempotentHint: true,
@@ -126,7 +135,7 @@ export const suggestA11yFixesTool = async params => {
         availableFixTypes: Object.keys(accessibilityFixes),
         suggestions: ['Try describing the issue with keywords like: button, label, missing, text, color, contrast, focus, etc.', 'Use axe-core violation IDs or descriptions directly', 'Be more specific about the element type (button, input, image, etc.)'],
         additionalResources: ['https://atlassian.design/llms-a11y.txt - Complete ADS accessibility documentation', 'https://atlassian.design/foundations/accessibility - ADS accessibility foundation'],
-        recommendation: 'Try the get_a11y_guidelines tool for component-specific guidance'
+        recommendation: 'Try the ads_get_a11y_guidelines tool for component-specific guidance'
       }, null, 2)
     }]
   };