@atlaskit/ads-mcp 0.20.2 → 0.20.4

package/dist/esm/index.js

@@ -5,23 +5,56 @@ import _regeneratorRuntime from "@babel/runtime/regenerator";
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ListToolsRequestSchema, McpError } from '@modelcontextprotocol/sdk/types.js';
-import { sendOperationalEvent } from './helpers/analytics';
+import { sendOperationalEvent } from './helpers/send-operational-event';
 import { validateToolArguments } from './helpers/validation';
 import { instructions } from './instructions';
-import { analyzeA11yInputSchema, analyzeA11yLocalhostInputSchema, analyzeA11yTool, analyzeLocalhostA11yTool, listAnalyzeA11yTool, listAnalyzeLocalhostA11yTool } from './tools/analyze-a11y';
-import { getA11yGuidelinesInputSchema, getA11yGuidelinesTool, listGetA11yGuidelinesTool } from './tools/get-a11y-guidelines';
-import { getAllComponentsTool, listGetAllComponentsTool } from './tools/get-all-components';
-import { getAllIconsTool, listGetAllIconsTool } from './tools/get-all-icons';
-import { getAllTokensTool, listGetAllTokensTool } from './tools/get-all-tokens';
-import { getGuidelinesInputSchema, getGuidelinesTool, listGetGuidelinesTool } from './tools/get-guidelines';
-import { getLintRulesInputSchema, getLintRulesTool, listGetLintRulesTool } from './tools/get-lint-rules';
-import { i18nConversionInputSchema, i18nConversionTool, listI18nConversionTool } from './tools/i18n-conversion';
-import { listMigrationGuidesTool, migrationGuidesInputSchema, migrationGuidesTool } from './tools/migration-guides';
-import { listPlanTool, planInputSchema, planTool } from './tools/plan';
-import { listSearchComponentsTool, searchComponentsInputSchema, searchComponentsTool } from './tools/search-components';
-import { listSearchIconsTool, searchIconsInputSchema, searchIconsTool } from './tools/search-icons';
-import { listSearchTokensTool, searchTokensInputSchema, searchTokensTool } from './tools/search-tokens';
-import { listSuggestA11yFixesTool, suggestA11yFixesInputSchema, suggestA11yFixesTool } from './tools/suggest-a11y-fixes';
+import { analyzeA11yInputSchema } from './tools/analyze-a11y/analyze-a11y-input-schema';
+import { analyzeA11yLocalhostInputSchema } from './tools/analyze-a11y/analyze-a11y-localhost-input-schema';
+import { analyzeA11yTool } from './tools/analyze-a11y/analyze-a11y-tool';
+import { analyzeLocalhostA11yTool } from './tools/analyze-a11y/analyze-localhost-a11y-tool';
+import { listAnalyzeA11yTool } from './tools/analyze-a11y/list-analyze-a11y-tool';
+import { listAnalyzeLocalhostA11yTool } from './tools/analyze-a11y/list-analyze-localhost-a11y-tool';
+import { getA11yGuidelinesInputSchema } from './tools/get-a11y-guidelines/get-a11y-guidelines-input-schema';
+import { getA11yGuidelinesTool } from './tools/get-a11y-guidelines/get-a11y-guidelines-tool';
+import { listGetA11yGuidelinesTool } from './tools/get-a11y-guidelines/list-get-a11y-guidelines-tool';
+import { getAllComponentsTool } from './tools/get-all-components/get-all-components-tool';
+import { listGetAllComponentsTool } from './tools/get-all-components/list-get-all-components-tool';
+import { getAllIconsTool } from './tools/get-all-icons/get-all-icons-tool';
+import { listGetAllIconsTool } from './tools/get-all-icons/list-get-all-icons-tool';
+import { getAllTokensTool } from './tools/get-all-tokens/get-all-tokens-tool';
+import { listGetAllTokensTool } from './tools/get-all-tokens/list-get-all-tokens-tool';
+import { getAtlaskitComponentsTool } from './tools/get-atlaskit-components/get-atlaskit-components-tool';
+import { listGetAtlaskitComponentsTool } from './tools/get-atlaskit-components/list-get-atlaskit-components-tool';
+import { getGuidelinesInputSchema } from './tools/get-guidelines/get-guidelines-input-schema';
+import { getGuidelinesTool } from './tools/get-guidelines/get-guidelines-tool';
+import { listGetGuidelinesTool } from './tools/get-guidelines/list-get-guidelines-tool';
+import { getLintRulesInputSchema } from './tools/get-lint-rules/get-lint-rules-input-schema';
+import { getLintRulesTool } from './tools/get-lint-rules/get-lint-rules-tool';
+import { listGetLintRulesTool } from './tools/get-lint-rules/list-get-lint-rules-tool';
+import { i18nConversionInputSchema } from './tools/i18n-conversion/i18n-conversion-input-schema';
+import { i18nConversionTool } from './tools/i18n-conversion/i18n-conversion-tool';
+import { listI18nConversionTool } from './tools/i18n-conversion/list-i18n-conversion-tool';
+import { listMigrationGuidesTool } from './tools/migration-guides/list-migration-guides-tool';
+import { migrationGuidesInputSchema } from './tools/migration-guides/migration-guides-input-schema';
+import { migrationGuidesTool } from './tools/migration-guides/migration-guides-tool';
+import { listPlanTool } from './tools/plan/list-plan-tool';
+import { planInputSchema } from './tools/plan/plan-input-schema';
+import { planTool } from './tools/plan/plan-tool';
+import { listSearchAtlaskitComponentsTool } from './tools/search-atlaskit-components/list-search-atlaskit-components-tool';
+import { searchAtlaskitComponentsInputSchema } from './tools/search-atlaskit-components/search-atlaskit-components-input-schema';
+import { searchAtlaskitComponentsTool } from './tools/search-atlaskit-components/search-atlaskit-components-tool';
+import { listSearchComponentsTool } from './tools/search-components/list-search-components-tool';
+import { searchComponentsInputSchema } from './tools/search-components/search-components-input-schema';
+import { searchComponentsTool } from './tools/search-components/search-components-tool';
+import { listSearchIconsTool } from './tools/search-icons/list-search-icons-tool';
+import { searchIconsInputSchema } from './tools/search-icons/search-icons-input-schema';
+import { searchIconsTool } from './tools/search-icons/search-icons-tool';
+import { listSearchTokensTool } from './tools/search-tokens/list-search-tokens-tool';
+import { searchTokensInputSchema } from './tools/search-tokens/search-tokens-input-schema';
+import { searchTokensTool } from './tools/search-tokens/search-tokens-tool';
+import { listSuggestA11yFixesTool } from './tools/suggest-a11y-fixes/list-suggest-a11y-fixes-tool';
+import { suggestA11yFixesInputSchema } from './tools/suggest-a11y-fixes/suggest-a11y-fixes-input-schema';
+import { suggestA11yFixesTool } from './tools/suggest-a11y-fixes/suggest-a11y-fixes-tool';
 
 // eslint-disable-next-line import/no-extraneous-dependencies -- this uses require because not all node versions this package supports use the same import assertions/attributes
 var pkgJson = require('@atlaskit/ads-mcp/package.json');
@@ -58,8 +91,8 @@ var generateLogger = function generateLogger(level) {
   };
 };
 export var getToolRegistry = function getToolRegistry() {
-  var _ref;
-  return _ref = {}, _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_ref, listAnalyzeA11yTool.name, {
+  var _registry;
+  var registry = (_registry = {}, _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_registry, listAnalyzeA11yTool.name, {
     handler: analyzeA11yTool,
     inputSchema: analyzeA11yInputSchema,
     tool: listAnalyzeA11yTool
@@ -99,7 +132,7 @@ export var getToolRegistry = function getToolRegistry() {
     handler: migrationGuidesTool,
     inputSchema: migrationGuidesInputSchema,
     tool: listMigrationGuidesTool
-  }), _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_ref, listI18nConversionTool.name, {
+  }), _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_registry, listI18nConversionTool.name, {
     handler: i18nConversionTool,
     inputSchema: i18nConversionInputSchema,
     tool: listI18nConversionTool
@@ -119,10 +152,19 @@ export var getToolRegistry = function getToolRegistry() {
     handler: getLintRulesTool,
     inputSchema: getLintRulesInputSchema,
     tool: listGetLintRulesTool
-  });
+  }), listGetAtlaskitComponentsTool.name, {
+    handler: getAtlaskitComponentsTool,
+    inputSchema: null,
+    tool: listGetAtlaskitComponentsTool
+  }), listSearchAtlaskitComponentsTool.name, {
+    handler: searchAtlaskitComponentsTool,
+    inputSchema: searchAtlaskitComponentsInputSchema,
+    tool: listSearchAtlaskitComponentsTool
+  }));
+  return registry;
 };
 server.setRequestHandler(ListToolsRequestSchema, /*#__PURE__*/function () {
-  var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(request, extra) {
+  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(request, extra) {
     var toolRegistry, tools;
     return _regeneratorRuntime.wrap(function _callee$(_context) {
       while (1) switch (_context.prev = _context.next) {
@@ -151,13 +193,13 @@ server.setRequestHandler(ListToolsRequestSchema, /*#__PURE__*/function () {
     }, _callee);
   }));
   return function (_x, _x2) {
-    return _ref2.apply(this, arguments);
+    return _ref.apply(this, arguments);
   };
 }());
 
 // Handle tool execution
 server.setRequestHandler(CallToolRequestSchema, /*#__PURE__*/function () {
-  var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(request, extra) {
+  var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(request, extra) {
     var toolRegistry, toolName, toolConfig, actionSubject, toolArguments, inputValidation, result, toolRegistryForError;
     return _regeneratorRuntime.wrap(function _callee2$(_context2) {
       while (1) switch (_context2.prev = _context2.next) {
@@ -265,7 +307,7 @@ server.setRequestHandler(CallToolRequestSchema, /*#__PURE__*/function () {
     }, _callee2, null, [[6, 20]]);
   }));
   return function (_x3, _x4) {
-    return _ref3.apply(this, arguments);
+    return _ref2.apply(this, arguments);
   };
 }());
 function runServer() {

package/dist/esm/tools/analyze-a11y/analyze-a11y-input-schema.js

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+export var analyzeA11yInputSchema = z.object({
+  code: z.string().describe('Source code of a React component or JSX snippet to analyze (string content only—no file path).'),
+  componentName: z.string().optional().describe('Optional label for the component under review (for summaries and reports).'),
+  context: z.string().optional().describe('Optional: how the component is used (e.g. in a form, modal) to improve suggestions.'),
+  includePatternAnalysis: z.boolean().default(true).describe('When true (default), runs regex-based heuristics on the code string (e.g. unlabeled buttons, missing alt) in addition to other analysis.').optional()
+});

package/dist/esm/tools/analyze-a11y/analyze-a11y-localhost-input-schema.js

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+export var analyzeA11yLocalhostInputSchema = z.object({
+  url: z.string().describe('Fully qualified page URL to load (e.g. `http://localhost:9000` or a dev URL). Must be reachable from this MCP process.'),
+  componentName: z.string().optional().describe('Optional label for reporting (e.g. feature or component under test).'),
+  context: z.string().optional().describe('Optional: route, user flow, or feature context for the analyzed page.'),
+  selector: z.string().optional().describe('Optional CSS selector to scope axe analysis to a subtree (e.g. `#my-form`, `[data-testid="panel"]`). Omit to analyze the whole document.')
+});

package/dist/esm/tools/analyze-a11y/analyze-a11y-tool.js

@@ -0,0 +1,235 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+import axe from 'axe-core';
+import { generateADSFixForViolation } from './generate-ads-fix-for-violation';
+var accessibilityPatterns = [{
+  pattern: /<button[^>]*>(?!.*aria-label|.*>.*<\/button>)/g,
+  violation: 'Button without accessible text',
+  severity: 'error',
+  suggestion: 'Use the ads_suggest_a11y_fixes tool for ADS Button solutions. Describe the issue as "button missing label", "empty button", or "button needs text".'
+}, {
+  pattern: /<img[^>]*>(?!.*alt=)/g,
+  violation: 'Image without alt text',
+  severity: 'error',
+  suggestion: 'Use the ads_suggest_a11y_fixes tool for ADS Image solutions. Describe the issue as "image missing alt", "missing alt text", or "image accessibility".'
+}, {
+  pattern: /<div[^>]*onClick[^>]*>/g,
+  violation: 'Clickable div without accessibility',
+  severity: 'warning',
+  suggestion: 'Use the ads_suggest_a11y_fixes tool for ADS solutions. Describe the issue as "clickable div", "interactive div", or "div with click handler".'
+}, {
+  pattern: /color:\s*['"]#[0-9a-fA-F]{3,6}['"]/g,
+  violation: 'Hardcoded color values',
+  severity: 'warning',
+  suggestion: 'Use the ads_suggest_a11y_fixes tool for design token solutions. Describe the issue as "hardcoded colors", "hex colors", or "design tokens".'
+}, {
+  pattern: /<input[^>]*>(?!.*id=)/g,
+  violation: 'Input without associated label',
+  severity: 'error',
+  suggestion: 'Use the ads_suggest_a11y_fixes tool for ADS form solutions. Describe the issue as "input missing label", "form field without label", or "unlabeled input".'
+}, {
+  pattern: /<div[^>]*role="button"[^>]*>/g,
+  violation: 'Custom button without full accessibility',
+  severity: 'warning',
+  suggestion: 'Use the ads_suggest_a11y_fixes tool for ADS Button/Focusable solutions. Describe the issue as "custom button", "div with button role", or "interactive element".'
+}, {
+  pattern: /style=\{[^}]*color[^}]*\}/g,
+  violation: 'Inline color styles',
+  severity: 'warning',
+  suggestion: 'Use the ads_suggest_a11y_fixes tool for design token solutions. Describe the issue as "inline styles", "hardcoded colors", or "color tokens".'
+}];
+var adsGuidelines = {
+  buttons: {
+    title: 'Button Accessibility',
+    guidelines: ['Always provide accessible labels for buttons', 'Use Button component for standard interactions', 'Use Focusable component for custom interactive elements', 'Avoid disabled buttons with tooltips', 'Ensure focus indicators are visible']
+  },
+  forms: {
+    title: 'Form Accessibility',
+    guidelines: ['Use TextField component for consistent labeling', 'Associate labels with inputs using id and htmlFor', 'Provide clear error messages with aria-describedby', 'Use MessageWrapper for form validation announcements']
+  },
+  images: {
+    title: 'Image Accessibility',
+    guidelines: ['Use Image component with proper alt text', 'Keep alt text under 125 characters', 'Leave alt="" for decorative images', 'Describe the purpose, not just the content']
+  },
+  colors: {
+    title: 'Color and Contrast',
+    guidelines: ['Use design tokens for consistent contrast ratios', 'Never rely on color alone for information', 'Use color.text tokens for proper contrast', 'Test with high contrast mode']
+  }
+};
+function mapAxeViolationsToADSFixes(violations) {
+  return violations.map(function (violation) {
+    var adsFix = generateADSFixForViolation(violation);
+    return _objectSpread(_objectSpread({}, violation), {}, {
+      type: adsFix.title,
+      // Use the specific fix key that matches fixes.ts
+      adsFix: adsFix,
+      severity: violation.impact === 'critical' || violation.impact === 'serious' ? 'error' : 'warning'
+    });
+  });
+}
+export var analyzeA11yTool = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(params) {
+    var code, componentName, context, _params$includePatter, includePatternAnalysis, violations, suggestions, axeResults, _axeResults$violation, _axeResults$passes, _axeResults$incomplet, results, adsViolations, relevantGuidelines, summary;
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          code = params.code, componentName = params.componentName, context = params.context, _params$includePatter = params.includePatternAnalysis, includePatternAnalysis = _params$includePatter === void 0 ? true : _params$includePatter;
+          violations = [];
+          suggestions = [];
+          axeResults = {};
+          _context.prev = 4;
+          _context.next = 7;
+          return axe.run({
+            fromFrames: ['iframe', 'html']
+          });
+        case 7:
+          results = _context.sent;
+          // Process axe-core results
+          if (results.violations && results.violations.length > 0) {
+            adsViolations = mapAxeViolationsToADSFixes(results.violations);
+            violations.push.apply(violations, _toConsumableArray(adsViolations));
+            axeResults.violations = results.violations;
+            axeResults.passes = results.passes;
+            axeResults.incomplete = results.incomplete;
+          }
+
+          // Include pattern-based analysis if requested
+          if (includePatternAnalysis) {
+            accessibilityPatterns.forEach(function (pattern) {
+              var matches = code.match(pattern.pattern);
+              if (matches) {
+                violations.push({
+                  type: pattern.violation,
+                  severity: pattern.severity,
+                  count: matches.length,
+                  suggestion: pattern.suggestion,
+                  adsFix: 'Use the ads_suggest_a11y_fixes tool for specific ADS component solutions',
+                  example: 'The ads_suggest_a11y_fixes tool provides detailed code examples',
+                  source: 'pattern-analysis'
+                });
+              }
+            });
+          }
+
+          // Generate ADS-specific suggestions
+          if (violations.length > 0) {
+            suggestions.push({
+              title: 'Accessibility Improvements Needed',
+              description: "Found ".concat(violations.length, " accessibility issues in your code."),
+              violations: violations,
+              nextSteps: ['Review each violation and apply the suggested fixes', 'Use ADS components instead of custom implementations', 'Test with screen readers and keyboard navigation', 'Run automated accessibility tests']
+            });
+          }
+
+          // Provide relevant ADS guidelines
+          relevantGuidelines = [];
+          if (code.includes('button') || code.includes('onClick')) {
+            relevantGuidelines.push(adsGuidelines.buttons);
+          }
+          if (code.includes('input') || code.includes('form')) {
+            relevantGuidelines.push(adsGuidelines.forms);
+          }
+          if (code.includes('img') || code.includes('image')) {
+            relevantGuidelines.push(adsGuidelines.images);
+          }
+          if (code.includes('color') || code.includes('style')) {
+            relevantGuidelines.push(adsGuidelines.colors);
+          }
+
+          // Generate summary
+          summary = {
+            componentName: componentName || 'Unknown component',
+            totalViolations: violations.length,
+            severityBreakdown: {
+              error: violations.filter(function (v) {
+                return v.severity === 'error';
+              }).length,
+              warning: violations.filter(function (v) {
+                return v.severity === 'warning';
+              }).length
+            },
+            context: context || 'No additional context provided',
+            axeResults: {
+              violations: ((_axeResults$violation = axeResults.violations) === null || _axeResults$violation === void 0 ? void 0 : _axeResults$violation.length) || 0,
+              passes: ((_axeResults$passes = axeResults.passes) === null || _axeResults$passes === void 0 ? void 0 : _axeResults$passes.length) || 0,
+              incomplete: ((_axeResults$incomplet = axeResults.incomplete) === null || _axeResults$incomplet === void 0 ? void 0 : _axeResults$incomplet.length) || 0
+            }
+          };
+          return _context.abrupt("return", {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                summary: summary,
+                violations: violations,
+                suggestions: suggestions,
+                relevantGuidelines: relevantGuidelines,
+                axeResults: axeResults,
+                recommendations: ['Use ADS components for better accessibility out of the box', 'Reference https://atlassian.design/llms-a11y.txt for detailed guidelines', 'Test with keyboard navigation and screen readers', 'Use automated accessibility testing tools']
+              }, null, 2)
+            }]
+          });
+        case 20:
+          _context.prev = 20;
+          _context.t0 = _context["catch"](4);
+          // Fallback to pattern-based analysis if axe-core fails
+          // console.warn('Axe-core analysis failed, falling back to pattern analysis:', error);
+
+          // Run pattern analysis as fallback
+          accessibilityPatterns.forEach(function (pattern) {
+            var matches = code.match(pattern.pattern);
+            if (matches) {
+              violations.push({
+                type: pattern.violation,
+                severity: pattern.severity,
+                count: matches.length,
+                suggestion: pattern.suggestion,
+                adsFix: 'Use the ads_suggest_a11y_fixes tool for specific ADS component solutions',
+                example: 'The ads_suggest_a11y_fixes tool provides detailed code examples',
+                source: 'pattern-analysis-fallback'
+              });
+            }
+          });
+          return _context.abrupt("return", {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                summary: {
+                  componentName: componentName || 'Unknown component',
+                  totalViolations: violations.length,
+                  severityBreakdown: {
+                    error: violations.filter(function (v) {
+                      return v.severity === 'error';
+                    }).length,
+                    warning: violations.filter(function (v) {
+                      return v.severity === 'warning';
+                    }).length
+                  },
+                  context: context || 'No additional context provided',
+                  note: 'Analysis completed using pattern matching (axe-core analysis failed)'
+                },
+                violations: violations,
+                suggestions: violations.length > 0 ? [{
+                  title: 'Accessibility Improvements Needed',
+                  description: "Found ".concat(violations.length, " accessibility issues in your code."),
+                  violations: violations,
+                  nextSteps: ['Review each violation and apply the suggested fixes', 'Use ADS components instead of custom implementations', 'Test with screen readers and keyboard navigation', 'Run automated accessibility tests']
+                }] : [],
+                error: 'Axe-core analysis failed, used pattern-based analysis as fallback',
+                recommendations: ['Use ADS components for better accessibility out of the box', 'Reference https://atlassian.design/llms-a11y.txt for detailed guidelines', 'Test with keyboard navigation and screen readers', 'Use automated accessibility testing tools']
+              }, null, 2)
+            }]
+          });
+        case 24:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee, null, [[4, 20]]);
+  }));
+  return function analyzeA11yTool(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();

package/dist/esm/tools/analyze-a11y/analyze-localhost-a11y-tool.js

@@ -0,0 +1,207 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+import { AxePuppeteer } from '@axe-core/puppeteer';
+import puppeteer from 'puppeteer';
+import { generateADSFixForViolation } from './generate-ads-fix-for-violation';
+var adsGuidelines = {
+  buttons: {
+    title: 'Button Accessibility',
+    guidelines: ['Always provide accessible labels for buttons', 'Use Button component for standard interactions', 'Use Focusable component for custom interactive elements', 'Avoid disabled buttons with tooltips', 'Ensure focus indicators are visible']
+  },
+  forms: {
+    title: 'Form Accessibility',
+    guidelines: ['Use TextField component for consistent labeling', 'Associate labels with inputs using id and htmlFor', 'Provide clear error messages with aria-describedby', 'Use MessageWrapper for form validation announcements']
+  },
+  images: {
+    title: 'Image Accessibility',
+    guidelines: ['Use Image component with proper alt text', 'Keep alt text under 125 characters', 'Leave alt="" for decorative images', 'Describe the purpose, not just the content']
+  },
+  colors: {
+    title: 'Color and Contrast',
+    guidelines: ['Use design tokens for consistent contrast ratios', 'Never rely on color alone for information', 'Use color.text tokens for proper contrast', 'Test with high contrast mode']
+  }
+};
+function mapAxeViolationsToADSFixes(violations) {
+  return violations.map(function (violation) {
+    var adsFix = generateADSFixForViolation(violation);
+    return _objectSpread(_objectSpread({}, violation), {}, {
+      type: adsFix.title,
+      // Use the specific fix key that matches fixes.ts
+      adsFix: adsFix,
+      severity: violation.impact === 'critical' || violation.impact === 'serious' ? 'error' : 'warning'
+    });
+  });
+}
+export var analyzeLocalhostA11yTool = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(params) {
+    var url, componentName, context, selector, violations, suggestions, axeResults, browser, page, _axeResults$violation, _axeResults$passes, _axeResults$incomplet, elementExists, availableElements, axePuppeteer, results, adsViolations, relevantGuidelines, summary;
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          url = params.url, componentName = params.componentName, context = params.context, selector = params.selector;
+          violations = [];
+          suggestions = [];
+          axeResults = {};
+          _context.next = 6;
+          return puppeteer.launch();
+        case 6:
+          browser = _context.sent;
+          _context.next = 9;
+          return browser.newPage();
+        case 9:
+          page = _context.sent;
+          _context.prev = 10;
+          _context.next = 13;
+          return page.goto(url, {
+            waitUntil: 'networkidle0'
+          });
+        case 13:
+          if (!selector) {
+            _context.next = 22;
+            break;
+          }
+          _context.next = 16;
+          return page.$(selector);
+        case 16:
+          elementExists = _context.sent;
+          if (elementExists) {
+            _context.next = 22;
+            break;
+          }
+          _context.next = 20;
+          return page.evaluate(function () {
+            var elements = Array.from(document.querySelectorAll('[id]'));
+            return elements.map(function (el) {
+              return "#".concat(el.id);
+            });
+          });
+        case 20:
+          availableElements = _context.sent;
+          throw new Error("Element with selector \"".concat(selector, "\" not found on the page after waiting. Available elements: ").concat(availableElements.join(', ')));
+        case 22:
+          // Run axe-core accessibility analysis
+          axePuppeteer = new AxePuppeteer(page); // If selector is provided, analyze only that element
+          if (selector) {
+            axePuppeteer.include(selector);
+          }
+          _context.next = 26;
+          return axePuppeteer.analyze();
+        case 26:
+          results = _context.sent;
+          if (results.violations && results.violations.length > 0) {
+            adsViolations = mapAxeViolationsToADSFixes(results.violations);
+            violations.push.apply(violations, _toConsumableArray(adsViolations));
+            axeResults.violations = results.violations;
+            axeResults.passes = results.passes;
+            axeResults.incomplete = results.incomplete;
+          }
+
+          // Generate ADS-specific suggestions
+          if (violations.length > 0) {
+            suggestions.push({
+              title: 'Accessibility Improvements Needed',
+              description: "Found ".concat(violations.length, " accessibility issues in your code."),
+              violations: violations,
+              nextSteps: ['Review each violation and apply the suggested fixes', 'Use ADS components instead of custom implementations', 'Test with screen readers and keyboard navigation', 'Run automated accessibility tests']
+            });
+          }
+
+          // Provide relevant ADS guidelines
+          relevantGuidelines = [];
+          if (url.includes('button') || url.includes('onClick')) {
+            relevantGuidelines.push(adsGuidelines.buttons);
+          }
+          if (url.includes('input') || url.includes('form')) {
+            relevantGuidelines.push(adsGuidelines.forms);
+          }
+          if (url.includes('img') || url.includes('image')) {
+            relevantGuidelines.push(adsGuidelines.images);
+          }
+          if (url.includes('color') || url.includes('style')) {
+            relevantGuidelines.push(adsGuidelines.colors);
+          }
+
+          // Generate summary
+          summary = {
+            url: url,
+            selector: selector || 'Entire page analyzed',
+            componentName: componentName || 'Unknown component',
+            totalViolations: violations.length,
+            severityBreakdown: {
+              error: violations.filter(function (v) {
+                return v.severity === 'error';
+              }).length,
+              warning: violations.filter(function (v) {
+                return v.severity === 'warning';
+              }).length
+            },
+            context: context || 'No additional context provided',
+            axeResults: {
+              violations: ((_axeResults$violation = axeResults.violations) === null || _axeResults$violation === void 0 ? void 0 : _axeResults$violation.length) || 0,
+              passes: ((_axeResults$passes = axeResults.passes) === null || _axeResults$passes === void 0 ? void 0 : _axeResults$passes.length) || 0,
+              incomplete: ((_axeResults$incomplet = axeResults.incomplete) === null || _axeResults$incomplet === void 0 ? void 0 : _axeResults$incomplet.length) || 0
+            }
+          };
+          _context.next = 37;
+          return browser.close();
+        case 37:
+          return _context.abrupt("return", {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                summary: summary,
+                violations: violations,
+                suggestions: suggestions,
+                relevantGuidelines: relevantGuidelines,
+                axeResults: axeResults,
+                recommendations: ['Use ADS components for better accessibility out of the box', 'Reference https://atlassian.design/llms-a11y.txt for detailed guidelines', 'Test with keyboard navigation and screen readers', 'Use automated accessibility testing tools']
+              }, null, 2)
+            }]
+          });
+        case 40:
+          _context.prev = 40;
+          _context.t0 = _context["catch"](10);
+          _context.next = 44;
+          return browser.close();
+        case 44:
+          return _context.abrupt("return", {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                summary: {
+                  url: url,
+                  selector: selector || 'Entire page analyzed',
+                  componentName: componentName || 'Unknown component',
+                  totalViolations: violations.length,
+                  severityBreakdown: {
+                    error: violations.filter(function (v) {
+                      return v.severity === 'error';
+                    }).length,
+                    warning: violations.filter(function (v) {
+                      return v.severity === 'warning';
+                    }).length
+                  },
+                  context: context || 'No additional context provided',
+                  note: 'Analysis failed to run on the provided URL'
+                },
+                violations: violations,
+                suggestions: [],
+                error: String(_context.t0),
+                recommendations: ['Use ADS components for better accessibility out of the box', 'Reference https://atlassian.design/llms-a11y.txt for detailed guidelines', 'Test with keyboard navigation and screen readers', 'Use automated accessibility testing tools']
+              }, null, 2)
+            }]
+          });
+        case 45:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee, null, [[10, 40]]);
+  }));
+  return function analyzeLocalhostA11yTool(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();

package/dist/esm/tools/analyze-a11y/generate-ads-fix-for-violation.js

@@ -0,0 +1,26 @@
+// Helper function to provide ADS-specific guidance for axe-core violations
+export function generateADSFixForViolation(violation) {
+  var id = violation.id,
+    description = violation.description,
+    help = violation.help,
+    tags = violation.tags;
+
+  // Provide general guidance without trying to map to specific fixes.ts keys
+  var adsFix = "Use the ads_suggest_a11y_fixes tool to get specific ADS component solutions. Describe the issue using the violation details: \"".concat(help, "\" or in your own words (e.g., \"button has no text\", \"missing alt text\", \"form field needs label\").");
+  return {
+    title: help,
+    // Use axe-core's human-readable description
+    description: description,
+    adsFix: adsFix,
+    example: 'The ads_suggest_a11y_fixes tool provides detailed code examples and ADS component solutions',
+    violationId: id,
+    axeHelp: help,
+    tags: tags,
+    wcagTags: tags.filter(function (tag) {
+      return tag.startsWith('wcag');
+    }),
+    // Extract WCAG compliance info
+    reference: "https://atlassian.design/llms-a11y.txt",
+    recommendations: ['Use ADS components for better accessibility out of the box', 'Reference the ads_suggest_a11y_fixes tool for specific solutions', 'Test with keyboard navigation and screen readers', 'Use automated accessibility testing tools']
+  };
+}

package/dist/esm/tools/analyze-a11y/list-analyze-a11y-tool.js

@@ -0,0 +1,14 @@
+import { zodToJsonSchema } from '../../helpers/zod-to-json-schema';
+import { analyzeA11yInputSchema } from './analyze-a11y-input-schema';
+export var listAnalyzeA11yTool = {
+  name: 'ads_analyze_a11y',
+  description: "Analyzes a **string of React/JSX** code for likely accessibility issues (heuristics and/or axe-related paths) and returns hints that often **point to** `ads_suggest_a11y_fixes` or generic axe/WCAG-style context\u2014not every finding maps to a specific ADS component fix.\n\nWHEN TO USE:\nYou have component source as text and want automated checks or heuristics before or during a code review.\n\nLIMITATIONS:\n- Does not replace testing in a real browser with assistive technologies or full keyboard traversal.\n- For rendered UI, `ads_analyze_localhost_a11y` (live URL + axe) is preferable when available\u2014it is **only exposed when this MCP runs locally**, not in the remote MCP deployment.",
+  annotations: {
+    title: 'Analyze accessibility (code string)',
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  inputSchema: zodToJsonSchema(analyzeA11yInputSchema)
+};