ai-ccesibility 0.1.0

package/dist/server.js

@@ -0,0 +1,2177 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import pino from 'pino';
+import { z } from 'zod';
+import puppeteer from 'puppeteer';
+import AxePuppeteer from '@axe-core/puppeteer';
+import pa11y from 'pa11y';
+import { ESLint } from 'eslint';
+
+// src/server.ts
+var logLevel = process.env["LOG_LEVEL"] ?? "info";
+var baseLogger = pino(
+  {
+    level: logLevel,
+    base: {
+      service: "ai-ccesibility",
+      version: "0.1.0"
+    },
+    timestamp: pino.stdTimeFunctions.isoTime,
+    formatters: {
+      level: (label) => ({ level: label })
+    }
+  },
+  pino.destination(2)
+);
+var logger = {
+  debug(message, context) {
+    baseLogger.debug(context ?? {}, message);
+  },
+  info(message, context) {
+    baseLogger.info(context ?? {}, message);
+  },
+  warn(message, context) {
+    baseLogger.warn(context ?? {}, message);
+  },
+  error(message, context) {
+    const { error, ...rest } = context ?? {};
+    if (error) {
+      baseLogger.error(
+        {
+          ...rest,
+          err: {
+            message: error.message,
+            name: error.name,
+            stack: error.stack
+          }
+        },
+        message
+      );
+    } else {
+      baseLogger.error(rest, message);
+    }
+  }
+};
+function createToolLogger(toolName) {
+  return {
+    debug(message, context) {
+      logger.debug(message, { ...context, tool: toolName });
+    },
+    info(message, context) {
+      logger.info(message, { ...context, tool: toolName });
+    },
+    warn(message, context) {
+      logger.warn(message, { ...context, tool: toolName });
+    },
+    error(message, context) {
+      logger.error(message, { ...context, tool: toolName });
+    }
+  };
+}
+function createAdapterLogger(adapterName) {
+  return {
+    debug(message, context) {
+      logger.debug(message, { ...context, adapter: adapterName });
+    },
+    info(message, context) {
+      logger.info(message, { ...context, adapter: adapterName });
+    },
+    warn(message, context) {
+      logger.warn(message, { ...context, adapter: adapterName });
+    },
+    error(message, context) {
+      logger.error(message, { ...context, adapter: adapterName });
+    }
+  };
+}
+function generateRequestId() {
+  return `req_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+
+// src/tools/base.ts
+function createTextResponse(text, isError = false) {
+  return {
+    content: [{ type: "text", text }],
+    isError
+  };
+}
+function createJsonResponse(data, isError = false) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    isError
+  };
+}
+function createErrorResponse(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return createTextResponse(`Error: ${message}`, true);
+}
+function withToolContext(toolName, handler) {
+  const toolLogger = createToolLogger(toolName);
+  return async (input) => {
+    const requestId = generateRequestId();
+    toolLogger.info("Tool execution started", { requestId });
+    const startTime = Date.now();
+    try {
+      const result = await handler(input, {
+        requestId,
+        logger: toolLogger
+      });
+      const duration = Date.now() - startTime;
+      toolLogger.info("Tool execution completed", {
+        requestId,
+        durationMs: duration,
+        isError: result.isError ?? false
+      });
+      return result;
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      toolLogger.error("Tool execution failed", {
+        requestId,
+        durationMs: duration,
+        error: error instanceof Error ? error : new Error(String(error))
+      });
+      return createErrorResponse(error);
+    }
+  };
+}
+
+// src/adapters/base.ts
+var BaseAdapter = class {
+  config;
+  logger;
+  constructor(config = {}) {
+    this.config = {
+      timeout: 3e4,
+      maxRetries: 1,
+      ...config
+    };
+    this.logger = createAdapterLogger(this.constructor.name);
+  }
+  async dispose() {
+    this.logger.debug("Adapter disposed");
+  }
+};
+
+// src/adapters/axe.ts
+var SEVERITY_MAP = {
+  critical: "critical",
+  serious: "serious",
+  moderate: "moderate",
+  minor: "minor"
+};
+var PRINCIPLE_MAP = {
+  "1": "perceivable",
+  "2": "operable",
+  "3": "understandable",
+  "4": "robust"
+};
+var AxeAdapter = class extends BaseAdapter {
+  name = "axe-core";
+  version = "4.x";
+  browser = null;
+  axeConfig;
+  constructor(config = {}) {
+    super(config);
+    this.axeConfig = {
+      headless: true,
+      browserArgs: ["--no-sandbox", "--disable-setuid-sandbox"],
+      ...config
+    };
+  }
+  async analyze(target, options) {
+    const startTime = Date.now();
+    let page = null;
+    try {
+      this.logger.info("Starting axe-core analysis", { target: target.value });
+      await this.ensureBrowser();
+      page = await this.browser.newPage();
+      if (target.options?.viewport) {
+        await page.setViewport(target.options.viewport);
+      }
+      await this.loadTarget(page, target);
+      const axeBuilder = new AxePuppeteer(page);
+      this.configureAxeBuilder(axeBuilder, options);
+      const results = await axeBuilder.analyze();
+      const issues = this.transformResults(results, options);
+      const duration = Date.now() - startTime;
+      this.logger.info("Analysis completed", { issueCount: issues.length, duration });
+      return this.buildSuccessResult(target.value, issues, results, duration);
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      this.logger.error("Analysis failed", { error, target: target.value });
+      return this.buildErrorResult(target.value, error, duration);
+    } finally {
+      if (page) {
+        await page.close().catch(() => {
+        });
+      }
+    }
+  }
+  async isAvailable() {
+    try {
+      await this.ensureBrowser();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async dispose() {
+    if (this.browser) {
+      await this.browser.close();
+      this.browser = null;
+      this.logger.debug("Browser closed");
+    }
+    await super.dispose();
+  }
+  async ensureBrowser() {
+    if (!this.browser || !this.browser.connected) {
+      this.logger.debug("Launching browser");
+      this.browser = await puppeteer.launch({
+        headless: this.axeConfig.headless ?? true,
+        args: this.axeConfig.browserArgs ?? ["--no-sandbox", "--disable-setuid-sandbox"]
+      });
+    }
+  }
+  async loadTarget(page, target) {
+    const timeout = target.options?.timeout ?? this.config.timeout ?? 3e4;
+    switch (target.type) {
+      case "url":
+        await page.goto(target.value, {
+          waitUntil: "networkidle2",
+          timeout
+        });
+        break;
+      case "html":
+        await page.setContent(target.value, {
+          waitUntil: "networkidle2",
+          timeout
+        });
+        break;
+      case "file":
+        await page.goto(`file://${target.value}`, {
+          waitUntil: "networkidle2",
+          timeout
+        });
+        break;
+    }
+    if (target.options?.waitForSelector) {
+      await page.waitForSelector(target.options.waitForSelector, { timeout });
+    }
+  }
+  configureAxeBuilder(builder, options) {
+    const tags = this.getWcagTags(options?.wcagLevel ?? "AA");
+    builder.withTags(tags);
+    if (options?.rules && options.rules.length > 0) {
+      builder.withRules(options.rules);
+    }
+    if (options?.excludeRules && options.excludeRules.length > 0) {
+      builder.disableRules(options.excludeRules);
+    }
+  }
+  getWcagTags(level) {
+    const baseTags = ["wcag2a", "wcag21a", "wcag22a", "best-practice"];
+    if (level === "AA" || level === "AAA") {
+      baseTags.push("wcag2aa", "wcag21aa", "wcag22aa");
+    }
+    if (level === "AAA") {
+      baseTags.push("wcag2aaa", "wcag21aaa", "wcag22aaa");
+    }
+    return baseTags;
+  }
+  transformResults(results, options) {
+    const issues = [];
+    let issueIndex = 0;
+    for (const violation of results.violations) {
+      for (const node of violation.nodes) {
+        issues.push(this.transformViolation(violation, node, issueIndex++));
+      }
+    }
+    if (options?.includeWarnings !== false) {
+      for (const incomplete of results.incomplete) {
+        for (const node of incomplete.nodes) {
+          issues.push(this.transformIncomplete(incomplete, node, issueIndex++));
+        }
+      }
+    }
+    return issues;
+  }
+  transformViolation(violation, node, index) {
+    return {
+      id: `axe-${index}`,
+      ruleId: violation.id,
+      tool: "axe-core",
+      severity: SEVERITY_MAP[violation.impact ?? "moderate"] ?? "moderate",
+      wcag: this.extractWcagReference(violation.tags),
+      location: this.extractLocation(node),
+      message: violation.help,
+      humanContext: violation.description,
+      suggestedActions: this.extractSuggestedActions(node),
+      affectedUsers: this.inferAffectedUsers(violation),
+      confidence: 1,
+      rawResult: { violation, node }
+    };
+  }
+  transformIncomplete(incomplete, node, index) {
+    return {
+      id: `axe-incomplete-${index}`,
+      ruleId: incomplete.id,
+      tool: "axe-core",
+      severity: "minor",
+      wcag: this.extractWcagReference(incomplete.tags),
+      location: this.extractLocation(node),
+      message: `[Requires review] ${incomplete.help}`,
+      humanContext: incomplete.description,
+      suggestedActions: this.extractSuggestedActions(node),
+      affectedUsers: this.inferAffectedUsers(incomplete),
+      confidence: 0.5,
+      rawResult: { incomplete, node }
+    };
+  }
+  extractLocation(node) {
+    return {
+      selector: node.target.join(" "),
+      xpath: node.xpath?.join(" "),
+      snippet: node.html?.substring(0, 500)
+    };
+  }
+  extractWcagReference(tags) {
+    const wcagTag = this.parseWcagTags(tags);
+    if (!wcagTag) return void 0;
+    const principle = wcagTag.criterion.charAt(0);
+    return {
+      criterion: wcagTag.criterion,
+      level: wcagTag.level,
+      principle: PRINCIPLE_MAP[principle] ?? "perceivable",
+      version: wcagTag.version
+    };
+  }
+  parseWcagTags(tags) {
+    const scPattern = /^wcag(\d{3,})$/;
+    const levelPattern = /^wcag2\d?(a{1,3})$/;
+    let criterion = null;
+    let level = "A";
+    let version = "2.0";
+    for (const tag of tags) {
+      const scMatch = tag.match(scPattern);
+      if (scMatch && scMatch[1]) {
+        const digits = scMatch[1];
+        if (digits.length >= 3) {
+          criterion = `${digits[0]}.${digits[1]}.${digits.slice(2)}`;
+        }
+      }
+      const levelMatch = tag.match(levelPattern);
+      if (levelMatch && levelMatch[1]) {
+        const levelStr = levelMatch[1].toUpperCase();
+        if (levelStr === "A" || levelStr === "AA" || levelStr === "AAA") {
+          level = levelStr;
+        }
+      }
+      if (tag.includes("21")) version = "2.1";
+      if (tag.includes("22")) version = "2.2";
+    }
+    if (!criterion) return null;
+    return { criterion, level, version };
+  }
+  extractSuggestedActions(node) {
+    const actions = [];
+    for (const check of node.any ?? []) {
+      if (check.message) {
+        actions.push(check.message);
+      }
+    }
+    for (const check of node.all ?? []) {
+      if (check.message) {
+        actions.push(check.message);
+      }
+    }
+    for (const check of node.none ?? []) {
+      if (check.message) {
+        actions.push(`Avoid: ${check.message}`);
+      }
+    }
+    return actions;
+  }
+  inferAffectedUsers(result) {
+    const users = /* @__PURE__ */ new Set();
+    const tags = result.tags.join(" ").toLowerCase();
+    const id = result.id.toLowerCase();
+    if (tags.includes("aria") || id.includes("aria") || id.includes("label") || id.includes("alt")) {
+      users.add("screen-reader");
+    }
+    if (id.includes("keyboard") || id.includes("focus") || id.includes("tabindex")) {
+      users.add("keyboard-only");
+      users.add("motor-impaired");
+    }
+    if (id.includes("color") || id.includes("contrast")) {
+      users.add("low-vision");
+      users.add("color-blind");
+    }
+    if (id.includes("heading") || id.includes("landmark") || id.includes("link")) {
+      users.add("screen-reader");
+      users.add("cognitive");
+    }
+    if (users.size === 0) {
+      users.add("screen-reader");
+    }
+    return Array.from(users);
+  }
+  buildSuccessResult(target, issues, axeResults, duration) {
+    const summary = this.calculateSummary(issues);
+    return {
+      success: true,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      duration,
+      target,
+      tool: "axe-core",
+      issues,
+      summary,
+      metadata: {
+        toolVersion: axeResults.testEngine?.version,
+        browserInfo: axeResults.testEnvironment?.userAgent,
+        pageTitle: axeResults.url
+      }
+    };
+  }
+  buildErrorResult(target, error, duration) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      duration,
+      target,
+      tool: "axe-core",
+      issues: [],
+      summary: {
+        total: 0,
+        bySeverity: { critical: 0, serious: 0, moderate: 0, minor: 0 }
+      },
+      error: errorMessage
+    };
+  }
+  calculateSummary(issues) {
+    const bySeverity = { critical: 0, serious: 0, moderate: 0, minor: 0 };
+    const byPrinciple = { perceivable: 0, operable: 0, understandable: 0, robust: 0 };
+    const byRule = {};
+    for (const issue of issues) {
+      bySeverity[issue.severity]++;
+      if (issue.wcag?.principle) {
+        byPrinciple[issue.wcag.principle]++;
+      }
+      byRule[issue.ruleId] = (byRule[issue.ruleId] ?? 0) + 1;
+    }
+    return {
+      total: issues.length,
+      bySeverity,
+      byPrinciple,
+      byRule
+    };
+  }
+};
+var SeveritySchema = z.enum(["critical", "serious", "moderate", "minor"]).describe(
+  "Impact level: critical (blocks users), serious (significant barrier), moderate (some difficulty), minor (annoyance)"
+);
+var WCAGLevelSchema = z.enum(["A", "AA", "AAA"]).describe("WCAG conformance level: A (minimum), AA (standard), AAA (enhanced)");
+var WCAGPrincipleSchema = z.enum(["perceivable", "operable", "understandable", "robust"]).describe(
+  "WCAG principle: perceivable (can sense), operable (can use), understandable (can comprehend), robust (works with assistive tech)"
+);
+var ToolSourceSchema = z.enum(["axe-core", "pa11y"]).describe("Source tool that detected the issue");
+var WCAGCriterionSchema = z.string().regex(/^\d+\.\d+\.\d+$/, "Must be in format X.Y.Z (e.g., 1.4.3)").describe("WCAG success criterion number (e.g., 1.4.3 for Contrast)");
+var WCAGReferenceSchema = z.object({
+  criterion: WCAGCriterionSchema,
+  level: WCAGLevelSchema,
+  principle: WCAGPrincipleSchema,
+  version: z.enum(["2.0", "2.1", "2.2"]).optional().describe("WCAG version"),
+  title: z.string().optional().describe("Human-readable criterion title"),
+  url: z.string().url().optional().describe("Link to WCAG documentation")
+}).describe("Reference to specific WCAG success criterion");
+var IssueLocationSchema = z.object({
+  selector: z.string().optional().describe("CSS selector to locate the element"),
+  xpath: z.string().optional().describe("XPath to locate the element"),
+  file: z.string().optional().describe("Source file path (for static analysis)"),
+  line: z.number().int().positive().optional().describe("Line number in source file"),
+  column: z.number().int().nonnegative().optional().describe("Column number in source file"),
+  snippet: z.string().max(500).optional().describe("HTML snippet of the problematic element")
+}).describe("Location information for the accessibility issue");
+var AccessibilityIssueSchema = z.object({
+  id: z.string().min(1).describe("Unique identifier for this issue instance"),
+  ruleId: z.string().min(1).describe("Rule identifier from the source tool"),
+  tool: ToolSourceSchema,
+  severity: SeveritySchema,
+  wcag: WCAGReferenceSchema.optional(),
+  location: IssueLocationSchema,
+  message: z.string().min(1).describe("Technical description of the issue"),
+  humanContext: z.string().optional().describe("User impact explanation for decision-making"),
+  suggestedActions: z.array(z.string()).optional().describe("Possible remediation approaches (not auto-fixes)"),
+  affectedUsers: z.array(
+    z.enum([
+      "screen-reader",
+      "keyboard-only",
+      "low-vision",
+      "color-blind",
+      "cognitive",
+      "motor-impaired"
+    ])
+  ).optional().describe("User groups most affected by this issue"),
+  priority: z.enum(["critical", "high", "medium", "low"]).optional().describe("Remediation priority based on impact"),
+  remediationEffort: z.enum(["low", "medium", "high"]).optional().describe("Estimated effort to fix"),
+  confidence: z.number().min(0).max(1).optional().describe("Tool confidence score (0-1)"),
+  rawResult: z.unknown().optional().describe("Original result from source tool for debugging")
+}).describe("Normalized accessibility issue from any source tool");
+var AnalysisSummarySchema = z.object({
+  total: z.number().int().nonnegative().describe("Total number of issues found"),
+  bySeverity: z.object({
+    critical: z.number().int().nonnegative().default(0),
+    serious: z.number().int().nonnegative().default(0),
+    moderate: z.number().int().nonnegative().default(0),
+    minor: z.number().int().nonnegative().default(0)
+  }).describe("Issue count by severity level"),
+  byPrinciple: z.object({
+    perceivable: z.number().int().nonnegative().default(0),
+    operable: z.number().int().nonnegative().default(0),
+    understandable: z.number().int().nonnegative().default(0),
+    robust: z.number().int().nonnegative().default(0)
+  }).optional().describe("Issue count by WCAG principle"),
+  byRule: z.record(z.string(), z.number().int().nonnegative()).optional().describe("Issue count grouped by rule ID")
+}).describe("Summary statistics for the analysis");
+var AnalysisResultSchema = z.object({
+  success: z.boolean().describe("Whether the analysis completed without errors"),
+  timestamp: z.string().datetime().describe("ISO 8601 timestamp of analysis"),
+  duration: z.number().int().nonnegative().optional().describe("Analysis duration in milliseconds"),
+  target: z.string().describe("URL, file path, or identifier of analyzed target"),
+  tool: ToolSourceSchema,
+  issues: z.array(AccessibilityIssueSchema).describe("List of accessibility issues found"),
+  summary: AnalysisSummarySchema,
+  metadata: z.object({
+    toolVersion: z.string().optional(),
+    browserInfo: z.string().optional(),
+    pageTitle: z.string().optional()
+  }).optional().describe("Additional context about the analysis"),
+  error: z.string().optional().describe("Error message if analysis failed")
+}).describe("Complete result of an accessibility analysis");
+z.object({
+  success: z.boolean(),
+  timestamp: z.string().datetime(),
+  duration: z.number().int().nonnegative().optional(),
+  target: z.string(),
+  toolsUsed: z.array(ToolSourceSchema),
+  issues: z.array(AccessibilityIssueSchema),
+  summary: AnalysisSummarySchema.extend({
+    byTool: z.record(ToolSourceSchema, z.number().int().nonnegative()).optional()
+  }),
+  individualResults: z.array(AnalysisResultSchema).optional().describe("Results from each tool before merging"),
+  error: z.string().optional()
+}).describe("Combined result from multiple accessibility tools");
+
+// src/types/tool-inputs.ts
+var UrlSchema = z.string().url().describe("URL of the page to analyze");
+var HtmlSchema = z.string().min(1).describe("Raw HTML content to analyze");
+var FilePathSchema = z.string().min(1).describe("Path to the file to analyze");
+var ViewportSchema = z.object({
+  width: z.number().int().positive().default(1280).describe("Viewport width in pixels"),
+  height: z.number().int().positive().default(720).describe("Viewport height in pixels")
+}).describe("Browser viewport dimensions");
+var BrowserOptionsSchema = z.object({
+  waitForSelector: z.string().optional().describe("CSS selector to wait for before analysis"),
+  waitForTimeout: z.number().int().positive().max(6e4).optional().describe("Time to wait in ms before analysis (max 60s)"),
+  viewport: ViewportSchema.optional()
+}).describe("Browser behavior options");
+var AxeToolInputSchema = z.object({
+  url: UrlSchema.optional(),
+  html: HtmlSchema.optional(),
+  options: z.object({
+    wcagLevel: WCAGLevelSchema.default("AA").describe("WCAG conformance level to check"),
+    rules: z.array(z.string()).optional().describe("Specific axe rule IDs to run"),
+    excludeRules: z.array(z.string()).optional().describe("Axe rule IDs to exclude"),
+    includeIncomplete: z.boolean().default(false).describe("Include incomplete/needs-review results"),
+    selector: z.string().optional().describe("CSS selector to scope analysis to specific element"),
+    browser: BrowserOptionsSchema.optional()
+  }).optional()
+}).refine((data) => data.url !== void 0 || data.html !== void 0, {
+  message: "Either url or html must be provided"
+}).refine((data) => !(data.url !== void 0 && data.html !== void 0), {
+  message: "Provide either url or html, not both"
+}).describe("Input for axe-core accessibility analysis");
+var Pa11yToolInputSchema = z.object({
+  url: UrlSchema.optional(),
+  html: HtmlSchema.optional(),
+  options: z.object({
+    standard: z.enum(["WCAG2A", "WCAG2AA", "WCAG2AAA", "WCAG21A", "WCAG21AA", "WCAG21AAA"]).default("WCAG21AA").describe("Accessibility standard to test against"),
+    includeWarnings: z.boolean().default(true).describe("Include warnings in results"),
+    includeNotices: z.boolean().default(false).describe("Include notices in results"),
+    rootElement: z.string().optional().describe("CSS selector for root element to test"),
+    hideElements: z.string().optional().describe("CSS selector for elements to hide from testing"),
+    browser: BrowserOptionsSchema.optional()
+  }).optional()
+}).refine((data) => data.url !== void 0 || data.html !== void 0, {
+  message: "Either url or html must be provided"
+}).refine((data) => !(data.url !== void 0 && data.html !== void 0), {
+  message: "Provide either url or html, not both"
+}).describe("Input for Pa11y accessibility analysis");
+var ESLintA11yToolInputSchema = z.object({
+  files: z.array(FilePathSchema).min(1).optional().describe("Array of file paths to lint"),
+  directory: z.string().optional().describe("Directory path to lint recursively"),
+  code: z.string().optional().describe("Inline Vue component code to lint"),
+  options: z.object({
+    rules: z.record(
+      z.string(),
+      z.union([z.enum(["off", "warn", "error"]), z.number().int().min(0).max(2)])
+    ).optional().describe("Override specific rule configurations"),
+    fix: z.literal(false).default(false).describe("Fix mode is disabled - MCP only reports issues")
+  }).optional()
+}).refine(
+  (data) => data.files !== void 0 || data.directory !== void 0 || data.code !== void 0,
+  { message: "Provide files, directory, or code to lint" }
+).describe("Input for ESLint Vue.js accessibility linting");
+var CombinedAnalysisInputSchema = z.object({
+  url: UrlSchema.optional(),
+  html: HtmlSchema.optional(),
+  tools: z.array(z.enum(["axe-core", "pa11y"])).min(1).default(["axe-core", "pa11y"]).describe("Tools to run for web analysis"),
+  options: z.object({
+    wcagLevel: WCAGLevelSchema.default("AA"),
+    deduplicateResults: z.boolean().default(true).describe("Merge similar issues from different tools"),
+    browser: BrowserOptionsSchema.optional()
+  }).optional()
+}).refine(
+  (data) => data.url !== void 0 || data.html !== void 0,
+  { message: "Provide url or html to analyze" }
+).describe("Input for combined web accessibility analysis (axe-core + Pa11y)");
+
+// src/tools/axe.ts
+var sharedAdapter = null;
+function getAdapter() {
+  if (!sharedAdapter) {
+    sharedAdapter = new AxeAdapter({
+      headless: true,
+      timeout: 3e4
+    });
+  }
+  return sharedAdapter;
+}
+async function disposeAdapter() {
+  if (sharedAdapter) {
+    await sharedAdapter.dispose();
+    sharedAdapter = null;
+  }
+}
+process.on("SIGINT", () => {
+  disposeAdapter().finally(() => process.exit(0));
+});
+process.on("SIGTERM", () => {
+  disposeAdapter().finally(() => process.exit(0));
+});
+function buildAnalysisTarget(input) {
+  if (input.url) {
+    return {
+      type: "url",
+      value: input.url,
+      options: {
+        waitForSelector: input.options?.browser?.waitForSelector,
+        timeout: input.options?.browser?.waitForTimeout,
+        viewport: input.options?.browser?.viewport
+      }
+    };
+  }
+  return {
+    type: "html",
+    value: input.html,
+    options: {
+      waitForSelector: input.options?.browser?.waitForSelector,
+      timeout: input.options?.browser?.waitForTimeout,
+      viewport: input.options?.browser?.viewport
+    }
+  };
+}
+function buildAnalysisOptions(input) {
+  return {
+    wcagLevel: input.options?.wcagLevel ?? "AA",
+    rules: input.options?.rules,
+    excludeRules: input.options?.excludeRules,
+    includeWarnings: input.options?.includeIncomplete ?? false
+  };
+}
+function formatOutput(result) {
+  return {
+    success: result.success,
+    target: result.target,
+    issueCount: result.issues.length,
+    issues: result.issues,
+    summary: result.summary,
+    metadata: result.metadata,
+    duration: result.duration,
+    error: result.error
+  };
+}
+var handleAxeAnalysis = withToolContext(
+  "analyze-with-axe",
+  async (input, context) => {
+    context.logger.debug("Building analysis configuration", {
+      hasUrl: !!input.url,
+      hasHtml: !!input.html,
+      wcagLevel: input.options?.wcagLevel ?? "AA"
+    });
+    const adapter = getAdapter();
+    const isAvailable = await adapter.isAvailable();
+    if (!isAvailable) {
+      return createErrorResponse(
+        new Error("Axe adapter is not available. Browser may have failed to launch.")
+      );
+    }
+    const target = buildAnalysisTarget(input);
+    const options = buildAnalysisOptions(input);
+    context.logger.info("Starting axe-core analysis", {
+      targetType: target.type,
+      target: target.type === "url" ? target.value : "[html content]"
+    });
+    const result = await adapter.analyze(target, options);
+    if (!result.success) {
+      context.logger.warn("Analysis completed with errors", {
+        error: result.error
+      });
+    }
+    const output = formatOutput(result);
+    return createJsonResponse(output, !result.success);
+  }
+);
+var AxeToolMcpInputSchema = z.object({
+  url: z.string().url().optional().describe("URL of the page to analyze"),
+  html: z.string().min(1).optional().describe("Raw HTML content to analyze"),
+  options: z.object({
+    wcagLevel: z.enum(["A", "AA", "AAA"]).default("AA").describe("WCAG conformance level to check"),
+    rules: z.array(z.string()).optional().describe("Specific axe rule IDs to run"),
+    excludeRules: z.array(z.string()).optional().describe("Axe rule IDs to exclude"),
+    includeIncomplete: z.boolean().default(false).describe("Include incomplete/needs-review results"),
+    selector: z.string().optional().describe("CSS selector to scope analysis"),
+    browser: z.object({
+      waitForSelector: z.string().optional().describe("CSS selector to wait for"),
+      waitForTimeout: z.number().int().positive().max(6e4).optional(),
+      viewport: z.object({
+        width: z.number().int().positive().default(1280),
+        height: z.number().int().positive().default(720)
+      }).optional()
+    }).optional()
+  }).optional()
+});
+var analyzeWithAxeTool = {
+  name: "analyze-with-axe",
+  description: `Analyze a web page or HTML content for accessibility issues using axe-core.
+
+Returns accessibility violations and incomplete checks based on WCAG guidelines.
+
+Input options
+- url: URL of the page to analyze
+- html: Raw HTML content to analyze (alternative to url)
+- options.wcagLevel: WCAG level to check (A, AA, or AAA). Default: AA
+- options.rules: Specific axe rule IDs to run
+- options.excludeRules: Axe rule IDs to exclude
+- options.includeIncomplete: Include needs-review results. Default: false
+- options.browser.waitForSelector: CSS selector to wait for before analysis
+- options.browser.viewport: Browser viewport dimensions
+
+Output
+- issues: Array of accessibility issues found
+- summary: Issue counts by severity and WCAG principle
+- metadata: Tool version and browser info`,
+  register(server2) {
+    server2.tool(
+      this.name,
+      this.description,
+      AxeToolMcpInputSchema.shape,
+      async (input) => {
+        const parseResult = AxeToolInputSchema.safeParse(input);
+        if (!parseResult.success) {
+          const errors = parseResult.error.errors.map((e) => `${e.path.join(".")}: ${e.message}`).join("; ");
+          const response2 = createErrorResponse(new Error(`Invalid input: ${errors}`));
+          return { content: response2.content };
+        }
+        const response = await handleAxeAnalysis(parseResult.data);
+        return { content: response.content };
+      }
+    );
+  }
+};
+
+// src/data/wcag-criteria.json
+var wcag_criteria_default = {
+  "1.1.1": {
+    criterion: "1.1.1",
+    level: "A",
+    principle: "perceivable",
+    title: "Contenido no textual",
+    description: "Todo contenido no textual debe tener una alternativa de texto que cumpla el mismo prop\xF3sito.",
+    userImpact: {
+      affectedUsers: ["screen-reader", "low-vision"],
+      impactDescription: "Los usuarios de lectores de pantalla no pueden acceder a la informaci\xF3n transmitida por im\xE1genes, iconos o gr\xE1ficos sin texto alternativo.",
+      realWorldExample: 'Un usuario ciego usando JAWS escuchar\xE1 "imagen" sin descripci\xF3n, perdiendo completamente el contexto.'
+    },
+    remediation: {
+      effort: "low",
+      priority: "critical",
+      commonSolutions: [
+        "A\xF1adir atributo alt descriptivo a im\xE1genes",
+        "Usar aria-label para iconos decorativos con funci\xF3n",
+        'Marcar im\xE1genes decorativas con alt="" vac\xEDo',
+        "Proporcionar transcripciones para audio/video"
+      ]
+    },
+    wcagUrl: "https://www.w3.org/WAI/WCAG21/Understanding/non-text-content.html"
+  },
+  "1.2.2": {
+    criterion: "1.2.2",
+    level: "A",
+    principle: "perceivable",
+    title: "Subt\xEDtulos (pregrabados)",
+    description: "Los medios sincronizados pregrabados deben tener subt\xEDtulos.",
+    userImpact: {
+      affectedUsers: ["screen-reader"],
+      impactDescription: "Usuarios sordos o con problemas de audici\xF3n no pueden acceder al contenido de audio.",
+      realWorldExample: "Una persona sorda no puede seguir un tutorial en video sin subt\xEDtulos."
+    },
+    remediation: {
+      effort: "medium",
+      priority: "high",
+      commonSolutions: [
+        "A\xF1adir track de subt\xEDtulos WebVTT",
+        "Usar servicios de transcripci\xF3n autom\xE1tica como punto de partida",
+        "Revisar y corregir subt\xEDtulos generados autom\xE1ticamente"
+      ]
+    },
+    wcagUrl: "https://www.w3.org/WAI/WCAG21/Understanding/captions-prerecorded.html"
+  },
+  "1.3.1": {
+    criterion: "1.3.1",
+    level: "A",
+    principle: "perceivable",
+    title: "Informaci\xF3n y relaciones",
+    description: "La informaci\xF3n, estructura y relaciones transmitidas visualmente pueden ser determinadas program\xE1ticamente.",
+    userImpact: {
+      affectedUsers: ["screen-reader", "cognitive"],
+      impactDescription: "Sin estructura sem\xE1ntica correcta, los usuarios no pueden navegar eficientemente ni entender las relaciones entre contenidos.",
+      realWorldExample: "Un usuario con lector de pantalla no puede saltar entre encabezados si se usan divs con estilos en lugar de elementos h1-h6."
+    },
+    remediation: {
+      effort: "medium",
+      priority: "high",
+      commonSolutions: [
+        "Usar elementos HTML sem\xE1nticos (nav, main, article, aside)",
+        "Usar headings (h1-h6) en orden jer\xE1rquico",
+        "Asociar labels con inputs correctamente",
+        "Usar listas (ul, ol) para contenido de lista",
+        "Usar tablas con th y scope para datos tabulares"
+      ]
+    },
+    wcagUrl: "https://www.w3.org/WAI/WCAG21/Understanding/info-and-relationships.html"
+  },
+  "1.4.3": {
+    criterion: "1.4.3",
+    level: "AA",
+    principle: "perceivable",
+    title: "Contraste m\xEDnimo",
+    description: "El texto debe tener una relaci\xF3n de contraste de al menos 4.5:1 (3:1 para texto grande).",
+    userImpact: {
+      affectedUsers: ["low-vision", "color-blind"],
+      impactDescription: "Texto con bajo contraste es dif\xEDcil o imposible de leer para personas con baja visi\xF3n o daltonismo.",
+      realWorldExample: "Un usuario con cataratas no puede leer texto gris claro sobre fondo blanco en un formulario."
+    },
+    remediation: {
+      effort: "low",
+      priority: "high",
+      commonSolutions: [
+        "Ajustar colores para cumplir ratio 4.5:1 m\xEDnimo",
+        "Usar herramientas como WebAIM Contrast Checker",
+        "Evitar depender solo del color para transmitir informaci\xF3n",
+        "Probar con simuladores de daltonismo"
+      ]
+    },
+    wcagUrl: "https://www.w3.org/WAI/WCAG21/Understanding/contrast-minimum.html"
+  },
+  "2.1.1": {
+    criterion: "2.1.1",
+    level: "A",
+    principle: "operable",
+    title: "Teclado",
+    description: "Toda funcionalidad debe ser operable mediante teclado.",
+    userImpact: {
+      affectedUsers: ["keyboard-only", "motor-impaired", "screen-reader"],
+      impactDescription: "Usuarios que no pueden usar mouse quedan completamente bloqueados de funcionalidades solo accesibles con eventos de rat\xF3n.",
+      realWorldExample: "Un usuario con par\xE1lisis cerebral no puede usar un dropdown que solo funciona con hover del mouse."
+    },
+    remediation: {
+      effort: "medium",
+      priority: "critical",
+      commonSolutions: [
+        "A\xF1adir manejadores de eventos de teclado (onKeyDown, onKeyPress)",
+        "Usar elementos interactivos nativos (button, a, input)",
+        "Asegurar que custom components sean focusables (tabindex)",
+        "Implementar navegaci\xF3n con Enter/Space en controles personalizados"
+      ]
+    },
+    wcagUrl: "https://www.w3.org/WAI/WCAG21/Understanding/keyboard.html"
+  },
+  "2.4.1": {
+    criterion: "2.4.1",
+    level: "A",
+    principle: "operable",
+    title: "Saltar bloques",
+    description: "Debe existir un mecanismo para saltar bloques de contenido repetidos.",
+    userImpact: {
+      affectedUsers: ["keyboard-only", "screen-reader"],
+      impactDescription: "Usuarios deben tabular por toda la navegaci\xF3n en cada p\xE1gina, perdiendo tiempo y paciencia.",
+      realWorldExample: "Un usuario ciego debe escuchar 30 links de navegaci\xF3n antes de llegar al contenido principal en cada p\xE1gina."
+    },
+    remediation: {
+      effort: "low",
+      priority: "medium",
+      commonSolutions: [
+        'A\xF1adir link "Saltar al contenido principal" al inicio',
+        "Usar landmarks ARIA correctamente (main, nav)",
+        "Implementar skip links visibles al recibir foco"
+      ]
+    },
+    wcagUrl: "https://www.w3.org/WAI/WCAG21/Understanding/bypass-blocks.html"
+  },
+  "2.4.3": {
+    criterion: "2.4.3",
+    level: "A",
+    principle: "operable",
+    title: "Orden del foco",
+    description: "El orden de foco debe ser l\xF3gico y predecible.",
+    userImpact: {
+      affectedUsers: ["keyboard-only", "screen-reader", "cognitive"],
+      impactDescription: "Orden de foco il\xF3gico confunde a usuarios y dificulta la navegaci\xF3n.",
+      realWorldExample: "El foco salta de un bot\xF3n a otro en la esquina opuesta, confundiendo al usuario sobre qu\xE9 elemento est\xE1 activo."
+    },
+    remediation: {
+      effort: "medium",
+      priority: "medium",
+      commonSolutions: [
+        "Evitar tabindex positivos (> 0)",
+        "Mantener DOM order que refleje orden visual",
+        "Usar CSS para reordenar visualmente, no tabindex",
+        "Probar navegaci\xF3n con Tab manualmente"
+      ]
+    },
+    wcagUrl: "https://www.w3.org/WAI/WCAG21/Understanding/focus-order.html"
+  },
+  "2.4.4": {
+    criterion: "2.4.4",
+    level: "A",
+    principle: "operable",
+    title: "Prop\xF3sito de los enlaces",
+    description: "El prop\xF3sito de cada enlace debe poder determinarse por el texto del enlace solo.",
+    userImpact: {
+      affectedUsers: ["screen-reader", "cognitive"],
+      impactDescription: 'Enlaces gen\xE9ricos como "click aqu\xED" no comunican destino o prop\xF3sito.',
+      realWorldExample: 'Un usuario con lector de pantalla navegando por lista de enlaces escucha 10 veces "m\xE1s informaci\xF3n" sin contexto.'
+    },
+    remediation: {
+      effort: "low",
+      priority: "medium",
+      commonSolutions: [
+        'Usar texto de enlace descriptivo ("Descargar informe anual 2023")',
+        'Evitar "click aqu\xED", "m\xE1s informaci\xF3n", "leer m\xE1s"',
+        "A\xF1adir aria-label con contexto si el texto visible debe ser corto",
+        "Incluir el contexto en el texto del enlace"
+      ]
+    },
+    wcagUrl: "https://www.w3.org/WAI/WCAG21/Understanding/link-purpose-in-context.html"
+  },
+  "3.2.2": {
+    criterion: "3.2.2",
+    level: "A",
+    principle: "understandable",
+    title: "Al recibir entradas",
+    description: "Cambiar el valor de un control no debe causar cambios de contexo inesperados.",
+    userImpact: {
+      affectedUsers: ["cognitive", "screen-reader"],
+      impactDescription: "Cambios autom\xE1ticos desorientan y pueden causar p\xE9rdida de contexto.",
+      realWorldExample: "Un select que auto-env\xEDa el formulario al cambiar sorprende al usuario que quer\xEDa explorar opciones."
+    },
+    remediation: {
+      effort: "low",
+      priority: "medium",
+      commonSolutions: [
+        "Requerir acci\xF3n expl\xEDcita (bot\xF3n) para enviar",
+        "Advertir al usuario si habr\xE1 cambio autom\xE1tico",
+        "Usar onChange solo para actualizar UI, no navegaci\xF3n",
+        'Proporcionar bot\xF3n "Aplicar" en lugar de auto-submit'
+      ]
+    },
+    wcagUrl: "https://www.w3.org/WAI/WCAG21/Understanding/on-input.html"
+  },
+  "4.1.2": {
+    criterion: "4.1.2",
+    level: "A",
+    principle: "robust",
+    title: "Nombre, funci\xF3n, valor",
+    description: "Componentes de interfaz deben exponer nombre, funci\xF3n, estados y propiedades program\xE1ticamente.",
+    userImpact: {
+      affectedUsers: ["screen-reader"],
+      impactDescription: "Controles personalizados sin sem\xE1ntica ARIA son invisibles o incomprensibles para tecnolog\xEDas asistivas.",
+      realWorldExample: "Un checkbox custom hecho con div no anuncia su estado (marcado/desmarcado) al lector de pantalla."
+    },
+    remediation: {
+      effort: "high",
+      priority: "critical",
+      commonSolutions: [
+        "Usar elementos HTML nativos cuando sea posible",
+        'A\xF1adir roles ARIA apropiados (role="button", "checkbox", etc.)',
+        "Implementar estados ARIA (aria-checked, aria-expanded)",
+        "Incluir aria-label o aria-labelledby para nombre accesible",
+        "Seguir patrones de dise\xF1o WAI-ARIA"
+      ]
+    },
+    wcagUrl: "https://www.w3.org/WAI/WCAG21/Understanding/name-role-value.html"
+  }
+};
+
+// src/utils/wcag-context.ts
+var WCAG_CRITERIA = wcag_criteria_default;
+function getWCAGContext(criterion) {
+  return WCAG_CRITERIA[criterion];
+}
+function enrichIssueWithContext(_issue, context) {
+  const humanContext = `
+**${context.title} (WCAG ${context.criterion} - Nivel ${context.level})**
+
+${context.description}
+
+**Impacto en usuarios:**
+${context.userImpact.impactDescription}
+
+**Ejemplo real:**
+${context.userImpact.realWorldExample}
+
+**Esfuerzo de correcci\xF3n:** ${context.remediation.effort}
+**Prioridad:** ${context.remediation.priority}
+  `.trim();
+  return {
+    humanContext,
+    suggestedActions: context.remediation.commonSolutions,
+    affectedUsers: context.userImpact.affectedUsers,
+    priority: context.remediation.priority,
+    remediationEffort: context.remediation.effort
+  };
+}
+
+// src/normalizers/base.ts
+var BaseNormalizer = class {
+  generateIssueId(tool, ruleId, selector) {
+    const base = `${tool}:${ruleId}`;
+    if (selector) {
+      const selectorHash = this.hashString(selector).toString(16);
+      return `${base}:${selectorHash}`;
+    }
+    return base;
+  }
+  mapImpactToSeverity(impact) {
+    const mapping = {
+      critical: "critical",
+      serious: "serious",
+      moderate: "moderate",
+      minor: "minor"
+    };
+    return mapping[impact ?? ""] ?? "moderate";
+  }
+  enrichWithHumanContext(issue) {
+    if (!issue.wcag?.criterion) {
+      return issue;
+    }
+    const context = getWCAGContext(issue.wcag.criterion);
+    if (!context) {
+      return issue;
+    }
+    const enrichment = enrichIssueWithContext(issue, context);
+    return {
+      ...issue,
+      humanContext: enrichment.humanContext,
+      suggestedActions: enrichment.suggestedActions,
+      affectedUsers: enrichment.affectedUsers,
+      priority: enrichment.priority,
+      remediationEffort: enrichment.remediationEffort
+    };
+  }
+  hashString(str) {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+      const char = str.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash = hash & hash;
+    }
+    return Math.abs(hash);
+  }
+};
+
+// src/normalizers/pa11y.ts
+var WCAG_PATTERN = /WCAG2(A{1,3})\.(Principle\d)\.Guideline\d+_\d+\.(\d+_\d+_\d+)/;
+var Pa11yNormalizer = class extends BaseNormalizer {
+  normalize(issues, context) {
+    return issues.map((issue) => this.normalizeIssue(issue, context));
+  }
+  normalizeIssue(issue, context) {
+    const wcagInfo = this.parseWcagCode(issue.code);
+    const baseIssue = {
+      id: this.generateIssueId("pa11y", issue.code, issue.selector),
+      ruleId: issue.code,
+      tool: "pa11y",
+      severity: this.mapTypeToSeverity(issue.type),
+      wcag: wcagInfo,
+      location: {
+        selector: issue.selector,
+        snippet: issue.context,
+        file: context.targetFile
+      },
+      message: issue.message,
+      confidence: issue.type === "error" ? 1 : 0.8
+    };
+    return this.enrichWithHumanContext(baseIssue);
+  }
+  mapTypeToSeverity(type) {
+    const mapping = {
+      error: "serious",
+      warning: "moderate",
+      notice: "minor"
+    };
+    return mapping[type] ?? "moderate";
+  }
+  parseWcagCode(code) {
+    const match = WCAG_PATTERN.exec(code);
+    if (!match) return void 0;
+    const [, levelStr, principleStr, criterionRaw] = match;
+    if (!levelStr || !principleStr || !criterionRaw) return void 0;
+    const level = levelStr;
+    const criterion = criterionRaw.replace(/_/g, ".");
+    const principleMap = {
+      Principle1: "perceivable",
+      Principle2: "operable",
+      Principle3: "understandable",
+      Principle4: "robust"
+    };
+    const principle = principleMap[principleStr];
+    if (!principle) return void 0;
+    return {
+      criterion,
+      level,
+      principle,
+      version: "2.1"
+    };
+  }
+};
+var pa11yNormalizer = new Pa11yNormalizer();
+
+// src/adapters/pa11y.ts
+var Pa11yAdapter = class extends BaseAdapter {
+  name = "pa11y";
+  version = "9.0.1";
+  adapterConfig;
+  constructor(config = {}) {
+    super(config);
+    this.adapterConfig = config;
+  }
+  async analyze(target, options) {
+    const startTime = Date.now();
+    const targetValue = target.value;
+    this.logger.info("Starting Pa11y analysis", { target: targetValue });
+    try {
+      const pa11yOptions = this.buildPa11yOptions(target, options);
+      const results = await this.runPa11y(target, pa11yOptions);
+      const issues = pa11yNormalizer.normalize(results.issues, {
+        tool: "pa11y",
+        targetUrl: target.type === "url" ? targetValue : void 0
+      });
+      const duration = Date.now() - startTime;
+      this.logger.info("Pa11y analysis completed", {
+        target: targetValue,
+        issueCount: issues.length,
+        durationMs: duration
+      });
+      return {
+        success: true,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        duration,
+        target: targetValue,
+        tool: "pa11y",
+        issues,
+        summary: this.buildSummary(issues),
+        metadata: {
+          toolVersion: this.version,
+          pageTitle: results.documentTitle
+        }
+      };
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.logger.error("Pa11y analysis failed", {
+        target: targetValue,
+        error: error instanceof Error ? error : new Error(errorMessage)
+      });
+      return {
+        success: false,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        duration,
+        target: targetValue,
+        tool: "pa11y",
+        issues: [],
+        summary: this.buildSummary([]),
+        error: errorMessage
+      };
+    }
+  }
+  async isAvailable() {
+    try {
+      return typeof pa11y === "function";
+    } catch {
+      return false;
+    }
+  }
+  buildPa11yOptions(target, options) {
+    const pa11yOpts = {
+      timeout: this.config.timeout,
+      wait: 0,
+      standard: this.mapWcagLevel(options?.wcagLevel ?? "AA"),
+      includeWarnings: options?.includeWarnings ?? true,
+      includeNotices: false
+    };
+    if (target.options?.viewport) {
+      pa11yOpts.viewport = {
+        width: target.options.viewport.width,
+        height: target.options.viewport.height
+      };
+    }
+    if (target.options?.waitForSelector) {
+      pa11yOpts.wait = 1e3;
+    }
+    if (target.options?.timeout) {
+      pa11yOpts.wait = target.options.timeout;
+    }
+    if (this.adapterConfig.chromeLaunchConfig) {
+      pa11yOpts.chromeLaunchConfig = this.adapterConfig.chromeLaunchConfig;
+    }
+    if (options?.rules && options.rules.length > 0) {
+      pa11yOpts.rules = options.rules;
+    }
+    if (options?.excludeRules && options.excludeRules.length > 0) {
+      pa11yOpts.ignore = options.excludeRules;
+    }
+    return pa11yOpts;
+  }
+  async runPa11y(target, options) {
+    if (target.type === "url") {
+      return pa11y(target.value, options);
+    }
+    if (target.type === "html") {
+      const htmlContent = target.value;
+      const dataUrl = `data:text/html;charset=utf-8,${encodeURIComponent(htmlContent)}`;
+      return pa11y(dataUrl, options);
+    }
+    throw new Error(`Unsupported target type: ${target.type}`);
+  }
+  mapWcagLevel(level) {
+    const mapping = {
+      A: "WCAG2A",
+      AA: "WCAG2AA",
+      AAA: "WCAG2AAA"
+    };
+    return mapping[level];
+  }
+  buildSummary(issues) {
+    const bySeverity = {
+      critical: 0,
+      serious: 0,
+      moderate: 0,
+      minor: 0
+    };
+    const byPrinciple = {
+      perceivable: 0,
+      operable: 0,
+      understandable: 0,
+      robust: 0
+    };
+    const byRule = {};
+    for (const issue of issues) {
+      bySeverity[issue.severity]++;
+      if (issue.wcag?.principle) {
+        byPrinciple[issue.wcag.principle]++;
+      }
+      byRule[issue.ruleId] = (byRule[issue.ruleId] ?? 0) + 1;
+    }
+    return {
+      total: issues.length,
+      bySeverity,
+      byPrinciple,
+      byRule
+    };
+  }
+};
+
+// src/tools/pa11y.ts
+var sharedAdapter2 = null;
+function getAdapter2() {
+  if (!sharedAdapter2) {
+    sharedAdapter2 = new Pa11yAdapter({
+      timeout: 3e4
+    });
+  }
+  return sharedAdapter2;
+}
+async function disposeAdapter2() {
+  if (sharedAdapter2) {
+    await sharedAdapter2.dispose();
+    sharedAdapter2 = null;
+  }
+}
+process.on("SIGINT", () => {
+  disposeAdapter2().finally(() => process.exit(0));
+});
+process.on("SIGTERM", () => {
+  disposeAdapter2().finally(() => process.exit(0));
+});
+function buildAnalysisTarget2(input) {
+  if (input.url) {
+    return {
+      type: "url",
+      value: input.url,
+      options: {
+        waitForSelector: input.options?.browser?.waitForSelector,
+        timeout: input.options?.browser?.waitForTimeout,
+        viewport: input.options?.browser?.viewport
+      }
+    };
+  }
+  return {
+    type: "html",
+    value: input.html,
+    options: {
+      waitForSelector: input.options?.browser?.waitForSelector,
+      timeout: input.options?.browser?.waitForTimeout,
+      viewport: input.options?.browser?.viewport
+    }
+  };
+}
+function buildAnalysisOptions2(input) {
+  const standardMap = {
+    "WCAG2A": "A",
+    "WCAG2AA": "AA",
+    "WCAG2AAA": "AAA",
+    "WCAG21A": "A",
+    "WCAG21AA": "AA",
+    "WCAG21AAA": "AAA"
+  };
+  const wcagLevel = input.options?.standard ? standardMap[input.options.standard] ?? "AA" : "AA";
+  return {
+    wcagLevel,
+    includeWarnings: input.options?.includeWarnings ?? true
+  };
+}
+function formatOutput2(result) {
+  return {
+    success: result.success,
+    target: result.target,
+    issueCount: result.issues.length,
+    issues: result.issues,
+    summary: result.summary,
+    metadata: result.metadata,
+    duration: result.duration,
+    error: result.error
+  };
+}
+var handlePa11yAnalysis = withToolContext(
+  "analyze-with-pa11y",
+  async (input, context) => {
+    context.logger.debug("Building analysis configuration", {
+      hasUrl: !!input.url,
+      hasHtml: !!input.html,
+      standard: input.options?.standard ?? "WCAG21AA"
+    });
+    const adapter = getAdapter2();
+    const isAvailable = await adapter.isAvailable();
+    if (!isAvailable) {
+      return createErrorResponse(
+        new Error("Pa11y adapter is not available. Browser may have failed to launch.")
+      );
+    }
+    const target = buildAnalysisTarget2(input);
+    const options = buildAnalysisOptions2(input);
+    context.logger.info("Starting Pa11y analysis", {
+      targetType: target.type,
+      target: target.type === "url" ? target.value : "[html content]"
+    });
+    const result = await adapter.analyze(target, options);
+    if (!result.success) {
+      context.logger.warn("Analysis completed with errors", {
+        error: result.error
+      });
+    }
+    const output = formatOutput2(result);
+    return createJsonResponse(output, !result.success);
+  }
+);
+var Pa11yToolMcpInputSchema = z.object({
+  url: z.string().url().optional().describe("URL of the page to analyze"),
+  html: z.string().min(1).optional().describe("Raw HTML content to analyze"),
+  options: z.object({
+    standard: z.enum(["WCAG2A", "WCAG2AA", "WCAG2AAA", "WCAG21A", "WCAG21AA", "WCAG21AAA"]).default("WCAG21AA").describe("Accessibility standard to test against"),
+    includeWarnings: z.boolean().default(true).describe("Include warnings in results"),
+    includeNotices: z.boolean().default(false).describe("Include notices in results"),
+    rootElement: z.string().optional().describe("CSS selector for root element to test"),
+    hideElements: z.string().optional().describe("CSS selector for elements to hide"),
+    browser: z.object({
+      waitForSelector: z.string().optional().describe("CSS selector to wait for"),
+      waitForTimeout: z.number().int().positive().max(6e4).optional(),
+      viewport: z.object({
+        width: z.number().int().positive().default(1280),
+        height: z.number().int().positive().default(720)
+      }).optional()
+    }).optional()
+  }).optional()
+});
+var analyzeWithPa11yTool = {
+  name: "analyze-with-pa11y",
+  description: `Analyze a web page or HTML content for accessibility issues using Pa11y.
+
+Returns accessibility violations based on WCAG guidelines.
+
+Input options
+- url: URL of the page to analyze
+- html: Raw HTML content to analyze (alternative to url)
+- options.standard: WCAG standard to test against (WCAG2A, WCAG2AA, WCAG2AAA, WCAG21A, WCAG21AA, WCAG21AAA). Default: WCAG21AA
+- options.includeWarnings: Include warnings in results. Default: true
+- options.includeNotices: Include notices in results. Default: false
+- options.rootElement: CSS selector for root element to test
+- options.hideElements: CSS selector for elements to hide from testing
+- options.browser.waitForSelector: CSS selector to wait for before analysis
+- options.browser.viewport: Browser viewport dimensions
+
+Output:
+- issues: Array of accessibility issues found
+- summary: Issue counts by severity and WCAG principle
+- metadata: Tool version and page info`,
+  register(server2) {
+    server2.tool(
+      this.name,
+      this.description,
+      Pa11yToolMcpInputSchema.shape,
+      async (input) => {
+        const parseResult = Pa11yToolInputSchema.safeParse(input);
+        if (!parseResult.success) {
+          const errors = parseResult.error.errors.map((e) => `${e.path.join(".")}: ${e.message}`).join("; ");
+          const response2 = createErrorResponse(new Error(`Invalid input: ${errors}`));
+          return { content: response2.content };
+        }
+        const response = await handlePa11yAnalysis(parseResult.data);
+        return { content: response.content };
+      }
+    );
+  }
+};
+
+// src/normalizers/eslint.ts
+var ESLINT_RULE_WCAG_MAP = {
+  "vuejs-accessibility/alt-text": { criterion: "1.1.1", principle: "perceivable" },
+  "vuejs-accessibility/anchor-has-content": { criterion: "2.4.4", principle: "operable" },
+  "vuejs-accessibility/aria-props": { criterion: "4.1.2", principle: "robust" },
+  "vuejs-accessibility/aria-role": { criterion: "4.1.2", principle: "robust" },
+  "vuejs-accessibility/aria-unsupported-elements": { criterion: "4.1.2", principle: "robust" },
+  "vuejs-accessibility/click-events-have-key-events": { criterion: "2.1.1", principle: "operable" },
+  "vuejs-accessibility/form-control-has-label": { criterion: "1.3.1", principle: "perceivable" },
+  "vuejs-accessibility/heading-has-content": { criterion: "1.3.1", principle: "perceivable" },
+  "vuejs-accessibility/iframe-has-title": { criterion: "2.4.1", principle: "operable" },
+  "vuejs-accessibility/interactive-supports-focus": { criterion: "2.1.1", principle: "operable" },
+  "vuejs-accessibility/label-has-for": { criterion: "1.3.1", principle: "perceivable" },
+  "vuejs-accessibility/media-has-caption": { criterion: "1.2.2", principle: "perceivable" },
+  "vuejs-accessibility/mouse-events-have-key-events": { criterion: "2.1.1", principle: "operable" },
+  "vuejs-accessibility/no-access-key": { criterion: "2.1.1", principle: "operable" },
+  "vuejs-accessibility/no-autofocus": { criterion: "2.4.3", principle: "operable" },
+  "vuejs-accessibility/no-distracting-elements": { criterion: "2.2.2", principle: "operable" },
+  "vuejs-accessibility/no-onchange": { criterion: "3.2.2", principle: "understandable" },
+  "vuejs-accessibility/no-redundant-roles": { criterion: "4.1.2", principle: "robust" },
+  "vuejs-accessibility/no-static-element-interactions": { criterion: "4.1.2", principle: "robust" },
+  "vuejs-accessibility/role-has-required-aria-props": { criterion: "4.1.2", principle: "robust" },
+  "vuejs-accessibility/tabindex-no-positive": { criterion: "2.4.3", principle: "operable" }
+};
+var ESLintNormalizer = class extends BaseNormalizer {
+  normalize(results, context) {
+    const issues = [];
+    for (const fileResult of results) {
+      for (const message of fileResult.messages) {
+        if (!message.ruleId) continue;
+        const issue = this.normalizeIssue(message, fileResult.filePath, context);
+        if (issue) {
+          issues.push(issue);
+        }
+      }
+    }
+    return issues;
+  }
+  normalizeIssue(message, filePath, _context) {
+    if (!message.ruleId) return null;
+    const wcagInfo = this.getWcagInfo(message.ruleId);
+    const baseIssue = {
+      id: this.generateIssueId("eslint-vuejs-a11y", message.ruleId, `${filePath}:${message.line}:${message.column}`),
+      ruleId: message.ruleId,
+      tool: "eslint-vuejs-a11y",
+      severity: this.mapSeverity(message.severity),
+      wcag: wcagInfo,
+      location: {
+        file: filePath,
+        line: message.line,
+        column: message.column,
+        snippet: message.source ?? void 0
+      },
+      message: message.message,
+      confidence: 1
+    };
+    return this.enrichWithHumanContext(baseIssue);
+  }
+  mapSeverity(severity) {
+    return severity === 2 ? "serious" : "moderate";
+  }
+  getWcagInfo(ruleId) {
+    const mapping = ESLINT_RULE_WCAG_MAP[ruleId];
+    if (!mapping) return void 0;
+    return {
+      criterion: mapping.criterion,
+      level: "A",
+      principle: mapping.principle,
+      version: "2.1"
+    };
+  }
+};
+var eslintNormalizer = new ESLintNormalizer();
+
+// src/adapters/eslint.ts
+var DEFAULT_ESLINT_RULES = {
+  "vuejs-accessibility/alt-text": "error",
+  "vuejs-accessibility/anchor-has-content": "error",
+  "vuejs-accessibility/aria-props": "error",
+  "vuejs-accessibility/aria-role": "error",
+  "vuejs-accessibility/aria-unsupported-elements": "error",
+  "vuejs-accessibility/click-events-have-key-events": "error",
+  "vuejs-accessibility/form-control-has-label": "error",
+  "vuejs-accessibility/heading-has-content": "error",
+  "vuejs-accessibility/iframe-has-title": "error",
+  "vuejs-accessibility/interactive-supports-focus": "error",
+  "vuejs-accessibility/label-has-for": "error",
+  "vuejs-accessibility/media-has-caption": "error",
+  "vuejs-accessibility/mouse-events-have-key-events": "error",
+  "vuejs-accessibility/no-access-key": "error",
+  "vuejs-accessibility/no-autofocus": "warn",
+  "vuejs-accessibility/no-distracting-elements": "error",
+  "vuejs-accessibility/no-onchange": "warn",
+  "vuejs-accessibility/no-redundant-roles": "warn",
+  "vuejs-accessibility/no-static-element-interactions": "error",
+  "vuejs-accessibility/role-has-required-aria-props": "error",
+  "vuejs-accessibility/tabindex-no-positive": "error"
+};
+var ESLintAdapter = class extends BaseAdapter {
+  name = "eslint-vuejs-a11y";
+  version = "2.4.1";
+  constructor(config = {}) {
+    super(config);
+  }
+  async analyze(target, options) {
+    const startTime = Date.now();
+    const targetValue = target.value;
+    this.logger.info("Starting ESLint a11y analysis", { target: targetValue, type: target.type });
+    try {
+      const eslint = await this.createESLintInstance(options);
+      const results = await this.runESLint(eslint, target);
+      const fileResults = results.map((r) => ({
+        filePath: r.filePath,
+        messages: r.messages.map((m) => ({
+          ruleId: m.ruleId,
+          severity: m.severity,
+          message: m.message,
+          line: m.line,
+          column: m.column,
+          endLine: m.endLine,
+          endColumn: m.endColumn,
+          nodeType: m.nodeType ?? void 0,
+          source: r.source
+        })),
+        errorCount: r.errorCount,
+        warningCount: r.warningCount
+      }));
+      const issues = eslintNormalizer.normalize(fileResults, {
+        tool: "eslint-vuejs-a11y"
+      });
+      const duration = Date.now() - startTime;
+      this.logger.info("ESLint a11y analysis completed", {
+        target: targetValue,
+        issueCount: issues.length,
+        durationMs: duration
+      });
+      return {
+        success: true,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        duration,
+        target: targetValue,
+        tool: "eslint-vuejs-a11y",
+        issues,
+        summary: this.buildSummary(issues),
+        metadata: {
+          toolVersion: this.version
+        }
+      };
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.logger.error("ESLint a11y analysis failed", {
+        target: targetValue,
+        error: error instanceof Error ? error : new Error(errorMessage)
+      });
+      return {
+        success: false,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        duration,
+        target: targetValue,
+        tool: "eslint-vuejs-a11y",
+        issues: [],
+        summary: this.buildSummary([]),
+        error: errorMessage
+      };
+    }
+  }
+  async isAvailable() {
+    try {
+      return typeof ESLint === "function";
+    } catch {
+      return false;
+    }
+  }
+  async createESLintInstance(options) {
+    const vuePlugin = await import('eslint-plugin-vuejs-accessibility');
+    const vueParser = await import('vue-eslint-parser');
+    const rules = { ...DEFAULT_ESLINT_RULES };
+    if (options?.rules) {
+      for (const rule of options.rules) {
+        rules[rule] = "error";
+      }
+    }
+    if (options?.excludeRules) {
+      for (const rule of options.excludeRules) {
+        rules[rule] = "off";
+      }
+    }
+    const plugin = vuePlugin.default ?? vuePlugin;
+    const parser = vueParser.default ?? vueParser;
+    const baseConfig = [
+      {
+        files: ["**/*.vue"],
+        languageOptions: {
+          parser,
+          parserOptions: {
+            ecmaVersion: "latest",
+            sourceType: "module"
+          }
+        },
+        plugins: {
+          "vuejs-accessibility": plugin
+        },
+        rules
+      }
+    ];
+    return new ESLint({
+      overrideConfigFile: true,
+      overrideConfig: baseConfig,
+      fix: false
+    });
+  }
+  async runESLint(eslint, target) {
+    if (target.type === "file") {
+      return eslint.lintFiles([target.value]);
+    }
+    if (target.type === "html") {
+      return eslint.lintText(target.value, {
+        filePath: "inline.vue"
+      });
+    }
+    throw new Error(`Unsupported target type for ESLint: ${target.type}. Use 'file' or 'html' (for inline Vue code).`);
+  }
+  buildSummary(issues) {
+    const bySeverity = {
+      critical: 0,
+      serious: 0,
+      moderate: 0,
+      minor: 0
+    };
+    const byPrinciple = {
+      perceivable: 0,
+      operable: 0,
+      understandable: 0,
+      robust: 0
+    };
+    const byRule = {};
+    for (const issue of issues) {
+      bySeverity[issue.severity]++;
+      if (issue.wcag?.principle) {
+        byPrinciple[issue.wcag.principle]++;
+      }
+      byRule[issue.ruleId] = (byRule[issue.ruleId] ?? 0) + 1;
+    }
+    return {
+      total: issues.length,
+      bySeverity,
+      byPrinciple,
+      byRule
+    };
+  }
+};
+
+// src/tools/eslint.ts
+var sharedAdapter3 = null;
+function getAdapter3() {
+  if (!sharedAdapter3) {
+    sharedAdapter3 = new ESLintAdapter({
+      timeout: 3e4
+    });
+  }
+  return sharedAdapter3;
+}
+async function disposeAdapter3() {
+  if (sharedAdapter3) {
+    await sharedAdapter3.dispose();
+    sharedAdapter3 = null;
+  }
+}
+process.on("SIGINT", () => {
+  disposeAdapter3().finally(() => process.exit(0));
+});
+process.on("SIGTERM", () => {
+  disposeAdapter3().finally(() => process.exit(0));
+});
+function buildAnalysisTarget3(input) {
+  if (input.files && input.files.length > 0) {
+    return {
+      type: "file",
+      value: input.files[0]
+    };
+  }
+  if (input.directory) {
+    return {
+      type: "file",
+      value: input.directory
+    };
+  }
+  return {
+    type: "html",
+    value: input.code
+  };
+}
+function buildAnalysisOptions3(_input) {
+  return {
+    wcagLevel: "AA",
+    includeWarnings: true
+  };
+}
+function formatOutput3(result) {
+  return {
+    success: result.success,
+    target: result.target,
+    issueCount: result.issues.length,
+    issues: result.issues,
+    summary: result.summary,
+    metadata: result.metadata,
+    duration: result.duration,
+    error: result.error
+  };
+}
+var handleESLintAnalysis = withToolContext(
+  "analyze-with-eslint",
+  async (input, context) => {
+    context.logger.debug("Building analysis configuration", {
+      hasFiles: !!(input.files && input.files.length > 0),
+      hasDirectory: !!input.directory,
+      hasCode: !!input.code
+    });
+    const adapter = getAdapter3();
+    const isAvailable = await adapter.isAvailable();
+    if (!isAvailable) {
+      return createErrorResponse(
+        new Error("ESLint adapter is not available.")
+      );
+    }
+    const target = buildAnalysisTarget3(input);
+    const options = buildAnalysisOptions3(input);
+    context.logger.info("Starting ESLint analysis", {
+      targetType: target.type,
+      target: target.type === "file" ? target.value : "[inline code]"
+    });
+    const result = await adapter.analyze(target, options);
+    if (!result.success) {
+      context.logger.warn("Analysis completed with errors", {
+        error: result.error
+      });
+    }
+    const output = formatOutput3(result);
+    return createJsonResponse(output, !result.success);
+  }
+);
+var ESLintToolMcpInputSchema = z.object({
+  files: z.array(z.string()).min(1).optional().describe("Array of file paths to lint"),
+  directory: z.string().optional().describe("Directory path to lint recursively"),
+  code: z.string().optional().describe("Inline Vue component code to lint"),
+  options: z.object({
+    rules: z.record(
+      z.string(),
+      z.union([z.enum(["off", "warn", "error"]), z.number().int().min(0).max(2)])
+    ).optional().describe("Override specific rule configurations"),
+    fix: z.literal(false).default(false).describe("Fix mode is disabled - MCP only reports issues")
+  }).optional()
+});
+var analyzeWithESLintTool = {
+  name: "analyze-with-eslint",
+  description: `Analyze Vue.js files for accessibility issues using ESLint with eslint-plugin-vuejs-accessibility.
+
+Performs static code analysis of Vue components.
+
+Input options:
+- files: Array of file paths to lint (must be .vue files)
+- directory: Directory path to lint recursively
+- code: Inline Vue component code to lint
+- options.rules: Override specific rule configurations (off, warn, error, or 0-2)
+- options.fix: Fix mode (always disabled - MCP only reports issues)
+
+Output:
+- issues: Array of accessibility issues found
+- summary: Issue counts by severity and WCAG principle
+- metadata: Tool version info`,
+  register(server2) {
+    server2.tool(
+      this.name,
+      this.description,
+      ESLintToolMcpInputSchema.shape,
+      async (input) => {
+        const parseResult = ESLintA11yToolInputSchema.safeParse(input);
+        if (!parseResult.success) {
+          const errors = parseResult.error.errors.map((e) => `${e.path.join(".")}: ${e.message}`).join("; ");
+          const response2 = createErrorResponse(new Error(`Invalid input: ${errors}`));
+          return { content: response2.content };
+        }
+        const response = await handleESLintAnalysis(parseResult.data);
+        return { content: response.content };
+      }
+    );
+  }
+};
+var sharedAxeAdapter = null;
+var sharedPa11yAdapter = null;
+function getAxeAdapter() {
+  if (!sharedAxeAdapter) {
+    sharedAxeAdapter = new AxeAdapter({ headless: true, timeout: 3e4 });
+  }
+  return sharedAxeAdapter;
+}
+function getPa11yAdapter() {
+  if (!sharedPa11yAdapter) {
+    sharedPa11yAdapter = new Pa11yAdapter({ timeout: 3e4 });
+  }
+  return sharedPa11yAdapter;
+}
+async function disposeAdapters() {
+  await Promise.all([
+    sharedAxeAdapter?.dispose(),
+    sharedPa11yAdapter?.dispose()
+  ]);
+  sharedAxeAdapter = null;
+  sharedPa11yAdapter = null;
+}
+function buildAnalysisTarget4(input) {
+  if (input.url) {
+    return {
+      type: "url",
+      value: input.url,
+      options: {
+        waitForSelector: input.options?.browser?.waitForSelector,
+        timeout: input.options?.browser?.waitForTimeout,
+        viewport: input.options?.browser?.viewport
+      }
+    };
+  }
+  return {
+    type: "html",
+    value: input.html,
+    options: {
+      waitForSelector: input.options?.browser?.waitForSelector,
+      timeout: input.options?.browser?.waitForTimeout,
+      viewport: input.options?.browser?.viewport
+    }
+  };
+}
+function buildAnalysisOptions4(input) {
+  return {
+    wcagLevel: input.options?.wcagLevel ?? "AA",
+    includeWarnings: true
+  };
+}
+function generateIssueFingerprint(issue) {
+  const parts = [
+    issue.ruleId,
+    issue.wcag?.criterion ?? "no-wcag",
+    issue.location.selector ?? issue.location.file ?? "no-location",
+    issue.message.substring(0, 50)
+  ];
+  return parts.join("|");
+}
+function deduplicateIssues(issues) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const issue of issues) {
+    const fingerprint = generateIssueFingerprint(issue);
+    if (!seen.has(fingerprint)) {
+      seen.set(fingerprint, issue);
+    } else {
+      const existing = seen.get(fingerprint);
+      if (issue.severity === "critical" && existing.severity !== "critical") {
+        seen.set(fingerprint, issue);
+      } else if (issue.confidence && existing.confidence && issue.confidence > existing.confidence) {
+        seen.set(fingerprint, issue);
+      }
+    }
+  }
+  return Array.from(seen.values());
+}
+function groupByWCAG(issues) {
+  const grouped = {};
+  for (const issue of issues) {
+    const key = issue.wcag?.criterion ?? "unknown";
+    if (!grouped[key]) {
+      grouped[key] = [];
+    }
+    grouped[key].push(issue);
+  }
+  return grouped;
+}
+function buildCombinedSummary(issues, _toolsUsed) {
+  const bySeverity = {
+    critical: 0,
+    serious: 0,
+    moderate: 0,
+    minor: 0
+  };
+  const byPrinciple = {
+    perceivable: 0,
+    operable: 0,
+    understandable: 0,
+    robust: 0
+  };
+  const byTool = {
+    "axe-core": 0,
+    "pa11y": 0
+  };
+  const byRule = {};
+  for (const issue of issues) {
+    bySeverity[issue.severity]++;
+    if (issue.wcag?.principle) {
+      byPrinciple[issue.wcag.principle]++;
+    }
+    byTool[issue.tool]++;
+    byRule[issue.ruleId] = (byRule[issue.ruleId] ?? 0) + 1;
+  }
+  return {
+    total: issues.length,
+    bySeverity,
+    byPrinciple,
+    byTool,
+    byRule
+  };
+}
+function formatOutput4(result, deduplicatedCount, issuesByWCAG) {
+  return {
+    success: result.success,
+    target: result.target,
+    toolsUsed: result.toolsUsed,
+    issueCount: result.issues.length,
+    deduplicatedCount,
+    issues: result.issues,
+    issuesByWCAG,
+    summary: result.summary,
+    individualResults: result.individualResults ?? [],
+    duration: result.duration,
+    error: result.error
+  };
+}
+var handleCombinedAnalysis = withToolContext(
+  "analyze-all",
+  async (input, context) => {
+    const startTime = Date.now();
+    const toolsToRun = input.tools ?? ["axe-core", "pa11y"];
+    const shouldDeduplicate = input.options?.deduplicateResults ?? true;
+    context.logger.info("Starting combined web analysis", {
+      tools: toolsToRun,
+      deduplicate: shouldDeduplicate,
+      hasUrl: !!input.url,
+      hasHtml: !!input.html
+    });
+    const target = buildAnalysisTarget4(input);
+    const options = buildAnalysisOptions4(input);
+    const results = [];
+    const errors = [];
+    const analysisPromises = [];
+    if (toolsToRun.includes("axe-core")) {
+      analysisPromises.push(
+        (async () => {
+          try {
+            const adapter = getAxeAdapter();
+            const result = await adapter.analyze(target, options);
+            results.push(result);
+            context.logger.debug("Axe analysis completed", { issueCount: result.issues.length });
+          } catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            errors.push(`Axe: ${msg}`);
+            context.logger.error("Axe analysis failed", {
+              error: error instanceof Error ? error : new Error(String(error))
+            });
+          }
+        })()
+      );
+    }
+    if (toolsToRun.includes("pa11y")) {
+      analysisPromises.push(
+        (async () => {
+          try {
+            const adapter = getPa11yAdapter();
+            const result = await adapter.analyze(target, options);
+            results.push(result);
+            context.logger.debug("Pa11y analysis completed", { issueCount: result.issues.length });
+          } catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            errors.push(`Pa11y: ${msg}`);
+            context.logger.error("Pa11y analysis failed", {
+              error: error instanceof Error ? error : new Error(String(error))
+            });
+          }
+        })()
+      );
+    }
+    await Promise.all(analysisPromises);
+    const allIssues = results.flatMap((r) => r.issues);
+    const originalCount = allIssues.length;
+    const finalIssues = shouldDeduplicate ? deduplicateIssues(allIssues) : allIssues;
+    const issuesByWCAG = groupByWCAG(finalIssues);
+    const duration = Date.now() - startTime;
+    context.logger.info("Combined analysis completed", {
+      totalIssues: originalCount,
+      deduplicatedIssues: finalIssues.length,
+      toolsRun: results.length,
+      errors: errors.length,
+      durationMs: duration
+    });
+    const combinedResult = {
+      success: errors.length === 0,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      duration,
+      target: target.value,
+      toolsUsed: results.map((r) => r.tool),
+      issues: finalIssues,
+      summary: buildCombinedSummary(finalIssues, toolsToRun),
+      individualResults: results,
+      error: errors.length > 0 ? errors.join("; ") : void 0
+    };
+    const output = formatOutput4(combinedResult, originalCount, issuesByWCAG);
+    return createJsonResponse(output, !combinedResult.success);
+  }
+);
+var CombinedToolMcpInputSchema = z.object({
+  url: z.string().url().optional().describe("URL of the page to analyze"),
+  html: z.string().min(1).optional().describe("Raw HTML content to analyze"),
+  tools: z.array(z.enum(["axe-core", "pa11y"])).min(1).default(["axe-core", "pa11y"]).describe("Tools to run for web analysis"),
+  options: z.object({
+    wcagLevel: z.enum(["A", "AA", "AAA"]).default("AA").describe("WCAG conformance level"),
+    deduplicateResults: z.boolean().default(true).describe("Merge similar issues from different tools"),
+    browser: z.object({
+      waitForSelector: z.string().optional().describe("CSS selector to wait for"),
+      waitForTimeout: z.number().int().positive().max(6e4).optional(),
+      viewport: z.object({
+        width: z.number().int().positive().default(1280),
+        height: z.number().int().positive().default(720)
+      }).optional()
+    }).optional()
+  }).optional()
+});
+var analyzeAllTool = {
+  name: "analyze-all",
+  description: `Run multiple accessibility analysis tools in parallel and combine results.
+
+Executes axe-core and Pa11y for web analysis (URL/HTML). Use analyze-with-eslint separately for Vue source code analysis.
+
+Input options:
+- url: URL of the page to analyze (required for web analysis)
+- html: Raw HTML content (alternative to url for web analysis)
+- tools: Array of tools to run ['axe-core', 'pa11y']. Default: ['axe-core', 'pa11y']
+- options.wcagLevel: WCAG level (A, AA, AAA). Default: AA
+- options.deduplicateResults: Merge similar issues from different tools. Default: true
+- options.browser.waitForSelector: CSS selector to wait for
+- options.browser.viewport: Browser viewport dimensions
+
+Output:
+- issues: Combined and deduplicated accessibility issues
+- issuesByWCAG: Issues grouped by WCAG criterion
+- summary: Aggregated counts by severity, principle, and tool
+- individualResults: Full results from each tool
+- deduplicatedCount: Number of duplicate issues removed
+
+Note: For Vue source code analysis, use analyze-with-eslint separately.`,
+  register(server2) {
+    server2.tool(
+      this.name,
+      this.description,
+      CombinedToolMcpInputSchema.shape,
+      async (input) => {
+        const parseResult = CombinedAnalysisInputSchema.safeParse(input);
+        if (!parseResult.success) {
+          const errors = parseResult.error.errors.map((e) => `${e.path.join(".")}: ${e.message}`).join("; ");
+          const response2 = createErrorResponse(new Error(`Invalid input: ${errors}`));
+          return { content: response2.content };
+        }
+        const response = await handleCombinedAnalysis(parseResult.data);
+        return { content: response.content };
+      }
+    );
+  }
+};
+
+// src/server.ts
+var server = new McpServer({
+  name: "AI-ccesibility",
+  version: "0.1.0"
+});
+function registerTools() {
+  analyzeWithAxeTool.register(server);
+  logger.info("Registered tool: analyze-with-axe");
+  analyzeWithPa11yTool.register(server);
+  logger.info("Registered tool: analyze-with-pa11y");
+  analyzeWithESLintTool.register(server);
+  logger.info("Registered tool: analyze-with-eslint");
+  analyzeAllTool.register(server);
+  logger.info("Registered tool: analyze-all");
+}
+async function main() {
+  logger.info("Starting AI-ccesibility Server", {
+    version: "0.1.0",
+    tools: ["analyze-with-axe", "analyze-with-pa11y", "analyze-with-eslint", "analyze-all"]
+  });
+  registerTools();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  logger.info("AI-ccesibility Server connected and ready");
+}
+async function shutdown() {
+  logger.info("Shutting down AI-ccesibility Server");
+  await Promise.all([
+    disposeAdapter(),
+    disposeAdapter2(),
+    disposeAdapter3(),
+    disposeAdapters()
+  ]);
+  logger.info("All adapters disposed");
+  process.exit(0);
+}
+process.on("SIGINT", shutdown);
+process.on("SIGTERM", shutdown);
+main().catch((error) => {
+  logger.error("Failed to start MCP server", {
+    error: error instanceof Error ? error : new Error(String(error))
+  });
+  process.exit(1);
+});
+//# sourceMappingURL=server.js.map
+//# sourceMappingURL=server.js.map