@mindfiredigital/ignix-lite-mcp 1.2.0 → 1.3.0

package/dist/server.js

@@ -1,3 +1,5 @@
+#!/usr/bin/env node
+
 // src/server.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
@@ -6,1954 +8,33 @@ import {
   CallToolRequestSchema
 } from "@modelcontextprotocol/sdk/types.js";
 
-// src/manifests/index.ts
-import { readFileSync } from "fs";
+// src/context/api-context.ts
+import { readFileSync, existsSync } from "fs";
 import path from "path";
 import { fileURLToPath } from "url";
-
-// src/utils/tokenizer.ts
-import { encoding_for_model } from "tiktoken";
-var encoder = encoding_for_model("gpt-4");
-function getTokenCount(input) {
-  return encoder.encode(input).length;
-}
-
-// src/manifests/index.ts
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = path.dirname(__filename);
-function loadManifest(file) {
-  const manifestPath = path.resolve(__dirname, "manifests", file);
-  const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
-  manifest.tokens = getTokenCount(manifest.emmet);
-  return manifest;
-}
-var manifests = {
-  accordion: loadManifest("accordion.json"),
-  alert: loadManifest("alert.json"),
-  avatar: loadManifest("avatar.json"),
-  badge: loadManifest("badge.json"),
-  breadcrumb: loadManifest("breadcrumb.json"),
-  button: loadManifest("button.json"),
-  card: loadManifest("card.json"),
-  checkbox: loadManifest("checkbox.json"),
-  codeblock: loadManifest("codeblock.json"),
-  combobox: loadManifest("combobox.json"),
-  dialog: loadManifest("dialog.json"),
-  divider: loadManifest("divider.json"),
-  dropdown: loadManifest("dropdown.json"),
-  form: loadManifest("form.json"),
-  grid: loadManifest("grid.json"),
-  input: loadManifest("input.json"),
-  meter: loadManifest("meter.json"),
-  navigation: loadManifest("navigation.json"),
-  progress: loadManifest("progress.json"),
-  radio: loadManifest("radio.json"),
-  select: loadManifest("select.json"),
-  skeleton: loadManifest("skeleton.json"),
-  tab: loadManifest("tab.json"),
-  table: loadManifest("table.json"),
-  textarea: loadManifest("textarea.json"),
-  toast: loadManifest("toast.json"),
-  tooltip: loadManifest("tooltip.json")
-};
-
-// src/tools/list-components.ts
-function listComponents() {
-  const components = Object.keys(manifests).sort();
-  return {
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify({
-          components,
-          count: components.length,
-          tokens_used: components.length
-        })
-      }
-    ]
-  };
-}
-
-// src/tools/get-manifests.ts
-import { z } from "zod";
-var schema = z.object({
-  name: z.string()
-});
-function getManifest(args) {
-  const parsed = schema.safeParse(args);
-  if (!parsed.success) {
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify({
-            error: "Invalid input",
-            suggestion: "Expected { name: string }",
-            tokens_used: 2
-          })
-        }
-      ]
-    };
-  }
-  const { name } = parsed.data;
-  const manifest = manifests[name];
-  if (!manifest) {
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify({
-            error: `Unknown component: ${name}`,
-            suggestion: "Call list_components() first",
-            tokens_used: 2
-          })
-        }
-      ]
-    };
-  }
-  return {
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify(manifest)
-      }
-    ]
-  };
-}
-
-// src/tools/get-emmet.ts
-import { z as z2 } from "zod";
-var schema2 = z2.object({
-  name: z2.string()
-});
-function getEmmet(args) {
-  const parsed = schema2.safeParse(args);
-  if (!parsed.success) {
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify({
-            error: "Invalid input",
-            suggestion: "Expected { name: string }",
-            tokens_used: 2
-          })
-        }
-      ]
-    };
-  }
-  const { name } = parsed.data;
-  const manifest = manifests[name];
-  if (!manifest) {
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify({
-            error: `Unknown component: ${name}`,
-            suggestion: "Call list_components() first",
-            tokens_used: 2
-          })
-        }
-      ]
-    };
-  }
-  return {
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify({
-          component: manifest.component,
-          emmet: manifest.emmet,
-          tokens: manifest.tokens,
-          tokens_used: 3
-        })
-      }
-    ]
-  };
-}
-
-// src/tools/validator.ts
-import { parse } from "node-html-parser";
-function validate(html) {
-  const root = parse(html);
-  const errors = [];
-  const elements = root.querySelectorAll("*");
-  const allowedWrappers = [
-    "label",
-    "span",
-    "p",
-    "img",
-    "small",
-    "h1",
-    "h2",
-    "h3",
-    "a",
-    "button",
-    "ul",
-    "li",
-    "thead",
-    "tbody",
-    "tr",
-    "td",
-    "th",
-    "summary"
-  ];
-  const nativeAttributes = /* @__PURE__ */ new Set([
-    "id",
-    "role",
-    "slot",
-    "tabindex",
-    "aria-label",
-    "aria-live",
-    "aria-hidden",
-    "aria-expanded",
-    "aria-selected",
-    "aria-current",
-    "aria-sort",
-    "aria-invalid",
-    "aria-describedby",
-    "aria-labelledby",
-    "aria-haspopup",
-    "aria-busy",
-    "disabled",
-    "required",
-    "checked",
-    "multiple",
-    "readonly",
-    "type",
-    "value",
-    "placeholder",
-    "name",
-    "min",
-    "max",
-    "low",
-    "high",
-    "optimum",
-    "rows",
-    "open",
-    "hidden",
-    "href",
-    "content",
-    "is",
-    "src",
-    "alt",
-    "data-intent",
-    "data-position",
-    "data-variant",
-    "data-shape",
-    "data-sortable",
-    "data-open",
-    "data-lines",
-    "data-grid",
-    "data-gap",
-    "data-align",
-    "data-justify",
-    "data-col",
-    "data-row",
-    "data-dense"
-  ]);
-  for (const el of elements) {
-    const tag = el.tagName.toLowerCase();
-    const attrs = el.attributes;
-    let manifestKey = tag.startsWith("ix-") ? tag.slice(3) : tag;
-    if (tag === "table" && attrs.is === "ix-table") {
-      manifestKey = "table";
-    }
-    if (tag === "nav") {
-      manifestKey = "navigation";
-    }
-    if (tag === "article" && el.querySelector("[slot]")) {
-      manifestKey = "card";
-    }
-    let manifest = manifests[manifestKey];
-    if (!manifest) {
-      if (tag === "mark") {
-        manifest = manifests.badge;
-      }
-      if (tag === "span" && attrs.role === "status") {
-        manifest = manifests.badge;
-      }
-    }
-    if (!manifest && !allowedWrappers.includes(tag)) {
-      errors.push({
-        element: tag,
-        prop: "",
-        type: "WRONG_ELEMENT",
-        message: `<${tag}> is not a valid ignix-lite component`,
-        fix: `<button>Fix me</button>`,
-        confidence: 0.7
-      });
-      continue;
-    }
-    if (!manifest) continue;
-    const elementName = tag.startsWith("ix-") ? tag : manifest.element || tag;
-    if (manifest.required_wrapper) {
-      const parent = el.parentNode;
-      if (!parent || parent.tagName?.toLowerCase() !== manifest.required_wrapper) {
-        errors.push({
-          element: tag,
-          prop: "wrapper",
-          type: "MISSING_REQUIRED",
-          message: `<${tag}> must be inside <${manifest.required_wrapper}>`,
-          fix: `<${manifest.required_wrapper}><${elementName}></${elementName}></${manifest.required_wrapper}>`,
-          confidence: 0.95
-        });
-      }
-    }
-    if (tag === "span" && manifest.component === "badge" && attrs.role !== "status") {
-      errors.push({
-        element: tag,
-        prop: "role",
-        type: "INVALID_VALUE",
-        message: "span badge must have role=status",
-        fix: `<span role="status">${el.innerText}</span>`,
-        confidence: 0.9
-      });
-    }
-    if ("class" in attrs) {
-      errors.push({
-        element: tag,
-        prop: "class",
-        type: "FORBIDDEN_CLASS",
-        message: "class attribute not allowed",
-        fix: `<${elementName}>${el.innerText}</${elementName}>`,
-        confidence: 0.99
-      });
-    }
-    if (Object.keys(attrs).length > 4) {
-      errors.push({
-        element: tag,
-        prop: "multiple",
-        type: "PROP_EXPLOSION",
-        message: "Too many props",
-        fix: `<${elementName}></${elementName}>`,
-        confidence: 0.85
-      });
-    }
-    for (const attr of Object.keys(attrs)) {
-      if (attr.startsWith("on")) {
-        errors.push({
-          element: tag,
-          prop: attr,
-          type: "JS_ON_CSS_COMPONENT",
-          message: "JS handlers forbidden",
-          fix: `<${elementName}></${elementName}>`,
-          confidence: 0.95
-        });
-      }
-    }
-    for (const attr of Object.keys(attrs)) {
-      if (manifest.forbidden_props?.includes(attr)) {
-        errors.push({
-          element: tag,
-          prop: attr,
-          type: "UNKNOWN_ATTRIBUTE",
-          message: `'${attr}' forbidden`,
-          fix: `<${elementName}></${elementName}>`,
-          confidence: 0.98
-        });
-        continue;
-      }
-      if (!manifest.props?.[attr] && !nativeAttributes.has(attr)) {
-        errors.push({
-          element: tag,
-          prop: attr,
-          type: "UNKNOWN_ATTRIBUTE",
-          message: `'${attr}' invalid`,
-          fix: `<${elementName}></${elementName}>`,
-          confidence: 0.95
-        });
-      }
-    }
-    for (const attr of Object.keys(attrs)) {
-      const def = manifest.props?.[attr];
-      if (def?.values) {
-        const value = attrs[attr];
-        if (!def.values.includes(value)) {
-          errors.push({
-            element: tag,
-            prop: attr,
-            type: "INVALID_VALUE",
-            message: `'${value}' invalid`,
-            valid_values: def.values,
-            fix: `<${elementName} ${attr}="${def.values[0]}"></${elementName}>`,
-            confidence: 0.97
-          });
-        }
-      }
-    }
-    for (const req of manifest.required_props || []) {
-      if (!(req in attrs)) {
-        errors.push({
-          element: tag,
-          prop: req,
-          type: "MISSING_REQUIRED",
-          message: `Missing ${req}`,
-          fix: `<${elementName} ${req}=""></${elementName}>`,
-          confidence: 0.9
-        });
-      }
-    }
-    const slots = manifest.slots ?? {};
-    for (const [slotName, slotDef] of Object.entries(slots)) {
-      const child = el.querySelector(`[slot="${slotName}"]`);
-      if (slotDef.required && !child) {
-        errors.push({
-          element: tag,
-          prop: slotName,
-          type: "MISSING_SLOT",
-          message: `Missing slot ${slotName}`,
-          fix: `<${elementName}><span slot="${slotName}"></span></${elementName}>`,
-          confidence: 0.95
-        });
-      }
-      if (child && slotDef.element) {
-        const childTag = child.tagName.toLowerCase();
-        if (!slotDef.element.includes(childTag)) {
-          errors.push({
-            element: childTag,
-            prop: slotName,
-            type: "INVALID_VALUE",
-            message: `${childTag} invalid for slot ${slotName}`,
-            valid_values: slotDef.element,
-            fix: `<${slotDef.element[0]} slot="${slotName}"></${slotDef.element[0]}>`,
-            confidence: 0.95
-          });
-        }
-      }
-    }
-  }
-  const valid = errors.length === 0;
-  const score = valid ? 100 : Math.max(0, 100 - errors.length * 10);
-  return {
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify({
-          valid,
-          score,
-          errors,
-          tokens_used: 50
-        })
-      }
-    ]
-  };
-}
-
-// src/tools/search-index.ts
-import path2 from "path";
-import { readFileSync as readFileSync2, existsSync } from "fs";
-import { fileURLToPath as fileURLToPath2 } from "url";
-
-// src/tools/embedder.ts
-var VOCAB_SIZE = 512;
-function embedText(text) {
-  const vector = new Array(VOCAB_SIZE).fill(0);
-  const words = text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter(Boolean);
-  words.forEach((word) => {
-    let hash = 0;
-    for (let i = 0; i < word.length; i++) {
-      hash = (hash * 31 + word.charCodeAt(i)) % VOCAB_SIZE;
-    }
-    vector[hash] += 1;
-  });
-  return vector;
-}
-
-// src/utils/cosine.ts
-function cosineSimilarity(a, b) {
-  let dot = 0;
-  let magA = 0;
-  let magB = 0;
-  for (let i = 0; i < a.length; i++) {
-    dot += a[i] * b[i];
-    magA += a[i] * a[i];
-    magB += b[i] * b[i];
-  }
-  if (magA === 0 || magB === 0) return 0;
-  return dot / (Math.sqrt(magA) * Math.sqrt(magB));
-}
-
-// src/tools/search-index.ts
-var __filename2 = fileURLToPath2(import.meta.url);
-var __dirname2 = path2.dirname(__filename2);
-var _index = null;
-function loadIndex() {
-  if (_index) return _index;
-  const indexPath = path2.resolve(__dirname2, "../../dist/vector-index.json");
-  if (!existsSync(indexPath)) {
-    console.warn(
-      `[search-index] dist/vector-index.json not found at: ${indexPath} - run pnpm build:index`
-    );
-    _index = [];
-    return _index;
-  }
-  try {
-    _index = JSON.parse(readFileSync2(indexPath, "utf8"));
-  } catch (err) {
-    console.error(`[search-index] Failed to load index from ${indexPath}:`, err);
-    _index = [];
-  }
-  return _index;
-}
-function searchIndex(description) {
-  const index = loadIndex();
-  const queryEmbedding = embedText(description);
-  const words = description.toLowerCase().split(/\s+/);
-  const ranked = index.map((item) => {
-    const similarity = cosineSimilarity(queryEmbedding, item.embedding);
-    let boost = 0;
-    const searchable = item.searchable.toLowerCase();
-    words.forEach((word) => {
-      if (item.name.toLowerCase() === word) {
-        boost += 2;
-      } else if (item.name.toLowerCase().includes(word)) {
-        boost += 1;
-      }
-      if (searchable.includes(word)) {
-        boost += 0.3;
-      }
-    });
-    return {
-      ...item,
-      score: similarity + boost
-    };
-  }).sort((a, b) => b.score - a.score);
-  return ranked.slice(0, 3);
-}
-
-// src/utils/intent-parser.ts
-import { readFileSync as readFileSync3, existsSync as existsSync2 } from "fs";
-import path3 from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
-
-// src/utils/intent-helpers.ts
-var STOP_WORDS = /* @__PURE__ */ new Set([
-  "with",
-  "for",
-  "and",
-  "the",
-  "you",
-  "can",
-  "from",
-  "this",
-  "that",
-  "your",
-  "want",
-  "need",
-  "show",
-  "give",
-  "nice",
-  "page",
-  "here",
-  "please",
-  "make",
-  "create",
-  "build",
-  "about",
-  "using",
-  "what",
-  "should",
-  "how"
-]);
-function tokenise(text) {
-  return text.toLowerCase().replace(/[^a-z0-9\s/]/g, " ").split(/[\s/]+/).filter((w) => w.length > 1 && !STOP_WORDS.has(w));
-}
-function editDistance(s1, s2) {
-  const costs = [];
-  for (let i = 0; i <= s1.length; i++) {
-    let lastValue = i;
-    for (let j = 0; j <= s2.length; j++) {
-      if (i === 0) {
-        costs[j] = j;
-      } else {
-        if (j > 0) {
-          let newValue = costs[j - 1];
-          if (s1.charAt(i - 1) !== s2.charAt(j - 1)) {
-            newValue = Math.min(Math.min(newValue, lastValue), costs[j]) + 1;
-          }
-          costs[j - 1] = lastValue;
-          lastValue = newValue;
-        }
-      }
-    }
-    if (i > 0) costs[s2.length] = lastValue;
-  }
-  return costs[s2.length];
-}
-function isSimilar(w1, w2) {
-  if (w1.length < 3 || w2.length < 3) return w1 === w2;
-  const maxDistance = w1.length >= 6 && w2.length >= 6 ? 2 : 1;
-  return editDistance(w1, w2) <= maxDistance;
-}
-
-// src/utils/intent-parser.ts
-function parseIntents(raw) {
-  const entries = [];
-  const intentStart = raw.indexOf("INTENTS:");
-  if (intentStart === -1) return entries;
-  const block = raw.slice(intentStart);
-  const lines = block.split(/\r?\n/);
-  let currentCategory = "GENERAL";
-  let pendingPhrase = null;
-  for (const raw_line of lines) {
-    const line = raw_line.trim();
-    if (line.startsWith("---") && line.endsWith("---")) {
-      currentCategory = line.replace(/^-+\s*/, "").replace(/\s*-+$/, "").trim();
-      pendingPhrase = null;
-      continue;
-    }
-    if (line.startsWith("[") && line.endsWith("]")) continue;
-    if (line.startsWith("never ")) continue;
-    if (line === "" || line.startsWith("\u2192")) continue;
-    if (line.startsWith("- ") && pendingPhrase !== null) {
-      const emmet2 = line.slice(2).trim();
-      entries.push({
-        name: pendingPhrase,
-        phrases: tokenise(pendingPhrase),
-        emmet: emmet2,
-        category: currentCategory
-      });
-      pendingPhrase = null;
-      continue;
-    }
-    if (!line.startsWith("-")) {
-      pendingPhrase = line;
-    }
-  }
-  return entries;
-}
-function loadIntents() {
-  try {
-    const currentDir = path3.dirname(fileURLToPath3(import.meta.url));
-    const path1 = path3.resolve(currentDir, "../../../api-full.txt");
-    const path22 = path3.resolve(currentDir, "../../api-full.txt");
-    const path32 = path3.resolve(currentDir, "../../../../api-full.txt");
-    let txtPath = path1;
-    if (existsSync2(path1)) {
-      txtPath = path1;
-    } else if (existsSync2(path22)) {
-      txtPath = path22;
-    } else if (existsSync2(path32)) {
-      txtPath = path32;
-    } else {
-      txtPath = path3.resolve(process.cwd(), "../../api-full.txt");
-    }
-    const raw = readFileSync3(txtPath, "utf8");
-    return parseIntents(raw);
-  } catch {
-    return [];
-  }
-}
-var _cache = null;
-function getIntentEntries() {
-  if (!_cache) {
-    _cache = loadIntents();
-  }
-  return _cache;
-}
-function scoreEntry(entry, queryWords) {
-  let score = 0;
-  const entryWords = new Set(entry.phrases);
-  let matchedCount = 0;
-  for (const qw of queryWords) {
-    let matched = false;
-    if (entryWords.has(qw)) {
-      score += 10;
-      matched = true;
-    } else {
-      for (const ew of entryWords) {
-        if (isSimilar(qw, ew)) {
-          score += 8;
-          matched = true;
-          break;
-        }
-      }
-      if (!matched) {
-        for (const ew of entryWords) {
-          if (ew.includes(qw) || qw.includes(ew)) {
-            score += 4;
-            matched = true;
-            break;
-          }
-        }
-      }
-    }
-    if (matched) {
-      matchedCount++;
-    }
-  }
-  const catWords = tokenise(entry.category);
-  for (const qw of queryWords) {
-    if (catWords.includes(qw)) {
-      score += 3;
-    } else {
-      for (const cw of catWords) {
-        if (isSimilar(qw, cw)) {
-          score += 2;
-          break;
-        }
-      }
-    }
-  }
-  const density = entry.phrases.length > 0 ? matchedCount / entry.phrases.length : 0;
-  return { score, density };
-}
-
-// src/utils/emmet-helpers.ts
-import emmet from "emmet";
-function expandEmmet(emmetStr) {
-  try {
-    return emmet(emmetStr);
-  } catch {
-    return `<!-- expand: ${emmetStr} -->`;
-  }
-}
-var ELEMENT_TO_COMPONENT = {
-  // Native elements
-  button: "button",
-  input: "input",
-  textarea: "textarea",
-  select: "select",
-  form: "form",
-  dialog: "dialog",
-  details: "accordion",
-  summary: "accordion",
-  progress: "progress",
-  meter: "meter",
-  aside: "alert",
-  mark: "badge",
-  img: "avatar",
-  article: "card",
-  nav: "navigation",
-  table: "table",
-  pre: "codeblock",
-  code: "codeblock",
-  hr: "divider",
-  label: "input",
-  // label wraps input/checkbox/radio
-  // Web components
-  "ix-tabs": "tab",
-  "ix-dropdown": "dropdown",
-  "ix-combobox": "combobox",
-  "ix-tooltip": "tooltip",
-  "ix-toast": "toast"
-};
-var SKELETON_PATTERN = /span\[[^\]]*(?:aria-busy|data-shape)[^\]]*\]/i;
-function extractComponents(emmetStr) {
-  const found = /* @__PURE__ */ new Set();
-  if (SKELETON_PATTERN.test(emmetStr)) {
-    found.add("skeleton");
-  }
-  if (/nav\[[^\]]*breadcrumb/i.test(emmetStr)) {
-    found.add("breadcrumb");
-  } else if (/\bnav\b/.test(emmetStr)) {
-    found.add("navigation");
-  }
-  if (/input\[[^\]]*type=checkbox/i.test(emmetStr)) {
-    found.add("checkbox");
-  }
-  if (/input\[[^\]]*type=radio/i.test(emmetStr)) {
-    found.add("radio");
-  }
-  if (/section\[[^\]]*data-grid/i.test(emmetStr)) {
-    found.add("grid");
-  }
-  const tagPattern = /(?:^|[>+(])([a-z][a-z0-9-]*)/gi;
-  let m;
-  while ((m = tagPattern.exec(emmetStr)) !== null) {
-    const tag = m[1].toLowerCase();
-    const component = ELEMENT_TO_COMPONENT[tag];
-    if (component) found.add(component);
-  }
-  return Array.from(found);
-}
-function interpolateEmmet(emmetStr, description) {
-  let result = emmetStr;
-  const descLower = description.toLowerCase();
-  if (/\b(red|danger|delete|remove|destroy)\b/.test(descLower)) {
-    result = result.replace(
-      /data-intent=(?:primary|neutral|ghost)/g,
-      "data-intent=danger"
-    );
-  } else if (/\b(green|success|work|done)\b/.test(descLower)) {
-    result = result.replace(
-      /data-intent=(?:primary|neutral|ghost)/g,
-      "data-intent=success"
-    );
-  } else if (/\b(yellow|orange|warning|risky)\b/.test(descLower)) {
-    result = result.replace(
-      /data-intent=(?:primary|neutral|ghost)/g,
-      "data-intent=warning"
-    );
-  }
-  const matches = [...description.matchAll(/['"]([^'"]+)['"]/g)];
-  const quotedStrings = matches.map((m) => m[1].trim()).filter((s) => s.length > 0);
-  if (quotedStrings.length > 0) {
-    const hasButtonMention = /\b(button|says|labeled|action|click)\b/i.test(
-      description
-    );
-    const shouldReplaceButton = quotedStrings.length >= 2 || quotedStrings.length === 1 && hasButtonMention;
-    if (shouldReplaceButton) {
-      const buttonRegex = /(button[^}]*)\{([^}]+)\}/g;
-      const buttonMatches = [...result.matchAll(buttonRegex)];
-      if (buttonMatches.length > 0) {
-        const buttonLabel = quotedStrings[quotedStrings.length - 1];
-        result = result.replace(buttonRegex, (match, p1) => {
-          return `${p1}{${buttonLabel}}`;
-        });
-        quotedStrings.pop();
-      }
-    }
-    const labelRegex = /label\{([^}]+)\}/g;
-    let quoteIndex = 0;
-    result = result.replace(labelRegex, (match) => {
-      if (quoteIndex < quotedStrings.length) {
-        return `label{${quotedStrings[quoteIndex++]}}`;
-      }
-      return match;
-    });
-    if (/label\{username\}/i.test(result)) {
-      result = result.replace(/type=email/g, "type=text");
-    }
-  }
-  return result;
-}
-
-// src/tools/intent-engine.ts
-var LAYER1_THRESHOLD = 8;
-function searchIntentTable(description) {
-  const entries = getIntentEntries();
-  if (entries.length === 0) return null;
-  const queryWords = tokenise(description);
-  const candidates = [];
-  let bestSingle = null;
-  for (const entry of entries) {
-    const { score, density } = scoreEntry(entry, queryWords);
-    if (score >= LAYER1_THRESHOLD) {
-      const components = extractComponents(entry.emmet);
-      candidates.push({ entry, score, density, components });
-      const isBetter = !bestSingle || score > bestSingle.score || score === bestSingle.score && density > bestSingle.density;
-      if (isBetter) {
-        bestSingle = {
-          name: entry.name,
-          emmet: entry.emmet,
-          score,
-          density,
-          source: "intent-table"
-        };
-      }
-    }
-  }
-  if (bestSingle && bestSingle.score >= 18) {
-    return bestSingle;
-  }
-  const isStitchRequested = /\b(and|plus|\+)\b/i.test(description) || description.includes(",");
-  if (isStitchRequested && candidates.length >= 2) {
-    candidates.sort((a, b) => b.score - a.score || b.density - a.density);
-    const selected = [];
-    const usedComponents = /* @__PURE__ */ new Set();
-    for (const c of candidates) {
-      const hasOverlap = c.components.some((comp) => usedComponents.has(comp));
-      if (!hasOverlap) {
-        selected.push(c);
-        c.components.forEach((comp) => usedComponents.add(comp));
-      }
-    }
-    if (selected.length >= 2) {
-      selected.sort((a, b) => {
-        const indexA = description.toLowerCase().indexOf(tokenise(a.entry.name)[0]);
-        const indexB = description.toLowerCase().indexOf(tokenise(b.entry.name)[0]);
-        return indexA - indexB;
-      });
-      const combinedEmmet = selected.map((s) => s.entry.emmet).join("+");
-      const totalScore = selected.reduce((sum, s) => sum + s.score, 0);
-      return {
-        name: selected.map((s) => s.entry.name).join(" and "),
-        emmet: combinedEmmet,
-        score: totalScore,
-        source: "intent-table"
-      };
-    }
-  }
-  return bestSingle;
-}
-function searchVectorLayer(description) {
-  const results = searchIndex(description);
-  if (results.length === 0) return null;
-  const top = results[0];
-  return {
-    name: top.name,
-    emmet: top.emmet,
-    score: top.score,
-    source: "vector-index"
-  };
-}
-async function howToBuild(description) {
-  let cleanDesc = description.trim();
-  if (cleanDesc.startsWith("{") && cleanDesc.endsWith("}")) {
-    try {
-      const parsed = JSON.parse(cleanDesc);
-      if (parsed && typeof parsed.description === "string") {
-        cleanDesc = parsed.description;
-      } else if (parsed && typeof parsed.text === "string") {
-        cleanDesc = parsed.text;
-      }
-    } catch {
-    }
-  }
-  let match = searchIntentTable(cleanDesc);
-  if (!match) {
-    match = searchVectorLayer(cleanDesc);
-  }
-  if (!match) {
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify({
-            emmet: "",
-            html: "",
-            components_used: [],
-            confidence: 0,
-            tokens: 0,
-            tokens_used: 15,
-            source: "no-match",
-            suggestion: "Call list_components() to see all available components, or try a different description."
-          })
-        }
-      ]
-    };
-  }
-  const emmet2 = interpolateEmmet(match.emmet, cleanDesc);
-  const components_used = extractComponents(emmet2);
-  const confidence = Math.min(1, match.score / 40);
-  return {
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify({
-          emmet: emmet2,
-          html: expandEmmet(emmet2),
-          components_used,
-          confidence: Number(confidence.toFixed(2)),
-          tokens: getTokenCount(emmet2),
-          tokens_used: 15,
-          source: match.source
-          // tells caller which layer matched
-        })
-      }
-    ]
-  };
-}
-
-// src/context/api-context.ts
-import { readFileSync as readFileSync4, existsSync as existsSync3 } from "fs";
-import path4 from "path";
-import { fileURLToPath as fileURLToPath4 } from "url";
-var __filename3 = fileURLToPath4(import.meta.url);
-var __dirname3 = path4.dirname(__filename3);
-var apiPath = path4.resolve(__dirname3, "../../../api-full.txt");
-if (!existsSync3(apiPath)) {
-  apiPath = path4.resolve(__dirname3, "../../../../api-full.txt");
-}
-var apiContext = readFileSync4(apiPath, "utf8");
-
-// src/tools/generate-theme.ts
-import { z as z3 } from "zod";
-
-// src/tools/theme-palette.ts
-var PALETTE = {
-  red: { primary: "#ef4444", contrast: "#ffffff" },
-  orange: { primary: "#f97316", contrast: "#ffffff" },
-  amber: { primary: "#f59e0b", contrast: "#111827" },
-  yellow: { primary: "#eab308", contrast: "#111827" },
-  lime: { primary: "#84cc16", contrast: "#111827" },
-  green: { primary: "#22c55e", contrast: "#ffffff" },
-  emerald: { primary: "#10b981", contrast: "#ffffff" },
-  teal: { primary: "#14b8a6", contrast: "#ffffff" },
-  cyan: { primary: "#06b6d4", contrast: "#111827" },
-  sky: { primary: "#0ea5e9", contrast: "#111827" },
-  blue: { primary: "#3b82f6", contrast: "#ffffff" },
-  indigo: { primary: "#6366f1", contrast: "#ffffff" },
-  violet: { primary: "#8b5cf6", contrast: "#ffffff" },
-  purple: { primary: "#a855f7", contrast: "#ffffff" },
-  fuchsia: { primary: "#d946ef", contrast: "#ffffff" },
-  pink: { primary: "#ec4899", contrast: "#ffffff" },
-  rose: { primary: "#f43f5e", contrast: "#ffffff" },
-  cyberpunk: { primary: "#ec4899", contrast: "#ffffff" },
-  neon: { primary: "#d946ef", contrast: "#ffffff" },
-  eco: { primary: "#10b981", contrast: "#ffffff" },
-  forest: { primary: "#0f766e", contrast: "#ffffff" },
-  coffee: { primary: "#78350f", contrast: "#ffffff" },
-  ocean: { primary: "#0284c7", contrast: "#ffffff" },
-  sunset: { primary: "#f97316", contrast: "#ffffff" },
-  midnight: { primary: "#3730a3", contrast: "#ffffff" },
-  lavender: { primary: "#8b5cf6", contrast: "#ffffff" },
-  coral: { primary: "#f43f5e", contrast: "#ffffff" },
-  slate: { primary: "#64748b", contrast: "#ffffff" },
-  gold: { primary: "#d97706", contrast: "#111827" },
-  silver: { primary: "#94a3b8", contrast: "#111827" }
-};
-function expandHex(hex) {
-  const h = hex.replace("#", "");
-  return h.length === 3 ? "#" + h[0] + h[0] + h[1] + h[1] + h[2] + h[2] : hex;
-}
-function contrastFor(hex6) {
-  const h = hex6.replace("#", "");
-  const r = parseInt(h.substring(0, 2), 16);
-  const g = parseInt(h.substring(2, 4), 16);
-  const b = parseInt(h.substring(4, 6), 16);
-  return (r * 299 + g * 587 + b * 114) / 1e3 > 165 ? "#111827" : "#ffffff";
-}
-function resolveColor(query) {
-  const hexMatch = query.match(/#([0-9a-fA-F]{6}|[0-9a-fA-F]{3})\b/);
-  if (hexMatch) {
-    const primary = expandHex(hexMatch[0]);
-    return { primary, contrast: contrastFor(primary) };
-  }
-  const sorted = Object.keys(PALETTE).sort((a, b) => b.length - a.length);
-  for (const name of sorted) {
-    if (query.includes(name)) return PALETTE[name];
-  }
-  return { primary: "#6366f1", contrast: "#ffffff" };
-}
-
-// src/tools/theme-tokens.ts
-function resolveTokens(query) {
-  const { primary, contrast } = resolveColor(query);
-  const isDark = query.includes("dark") || query.includes("night") || query.includes("midnight") || query.includes("cyberpunk") || query.includes("dim");
-  const sharp = query.includes("sharp") || query.includes("flat") || query.includes("square");
-  const round = query.includes("round") || query.includes("pill") || query.includes("soft");
-  return {
-    resolvedPrimary: primary,
-    resolvedContrast: contrast,
-    isDark,
-    primary,
-    primaryHover: isDark ? "color-mix(in srgb, var(--ix-primary) 75%, white)" : "color-mix(in srgb, var(--ix-primary) 85%, black)",
-    primaryContrast: isDark ? "color-mix(in srgb, var(--ix-primary) 40%, white)" : contrast,
-    primaryBg: isDark ? "color-mix(in srgb, var(--ix-primary) 20%, #0f172a)" : "color-mix(in srgb, var(--ix-primary) 15%, white)",
-    danger: "#ef4444",
-    dangerText: isDark ? "#f87171" : "#ef4444",
-    dangerBg: isDark ? "#3f1d1d" : "#fee2e2",
-    warning: isDark ? "#fbbf24" : "#f59e0b",
-    warningBg: isDark ? "#3f2e05" : "#fef3c7",
-    success: "#22c55e",
-    successBg: isDark ? "#052e16" : "#dcfce7",
-    infoBg: isDark ? "#1e293b" : "#f3f4f6",
-    neutral: isDark ? "#9ca3af" : "#6b7280",
-    divider: isDark ? "#475569" : "#9ca3af",
-    surface: isDark ? "#0f172a" : "#f9fafb",
-    surfaceRaised: isDark ? "#1e293b" : "#ffffff",
-    text: isDark ? "#f9fafb" : "#111827",
-    textMuted: isDark ? "#94a3b8" : "#6b7280",
-    border: isDark ? "#334155" : "#e5e7eb",
-    radius: sharp ? "0px" : round ? "0.75rem" : "0.375rem",
-    radiusLg: sharp ? "0px" : round ? "1rem" : "0.5rem",
-    badgeRadius: "999px",
-    skeletonBg: isDark ? "#1e293b" : "#e5e7eb",
-    skeletonShimmer: isDark ? "rgba(255,255,255,0.1)" : "rgba(255,255,255,0.6)",
-    gradientStart: primary,
-    gradientEnd: "#fffbd5",
-    gradientBgEnd: isDark ? "#aba67a" : "#d7d4bc"
-  };
-}
-function buildCss(t) {
-  return `:root {
-  --ix-primary:          ${t.primary};
-  --ix-primary-hover:    ${t.primaryHover};
-  --ix-primary-contrast: ${t.primaryContrast};
-
-  --ix-danger:      ${t.danger};
-  --ix-danger-text: ${t.dangerText};
-
-  --ix-warning: ${t.warning};
-  --ix-success: ${t.success};
-  --ix-neutral: ${t.neutral};
-  --ix-ghost:   transparent;
-
-  --ix-primary-bg: ${t.primaryBg};
-  --ix-danger-bg:  ${t.dangerBg};
-  --ix-warning-bg: ${t.warningBg};
-  --ix-success-bg: ${t.successBg};
-  --ix-info-bg:    ${t.infoBg};
-
-  --ix-on-danger:  #ffffff;
-  --ix-on-warning: #000000;
-  --ix-on-success: #ffffff;
-  --ix-on-primary: ${t.resolvedContrast};
-
-  --ix-divider: ${t.divider};
-
-  --ix-surface:        ${t.surface};
-  --ix-surface-raised: ${t.surfaceRaised};
-
-  --ix-text:       ${t.text};
-  --ix-text-muted: ${t.textMuted};
-
-  --ix-border: ${t.border};
-  --ix-focus:  2px solid var(--ix-primary);
-
-  --ix-font: 'Segoe UI Variable', 'Segoe UI', 'Roboto', 'Noto Sans', system-ui, sans-serif;
-  --ix-font-mono: 'JetBrains Mono', 'SFMono-Regular', Consolas, monospace;
-
-  --ix-size-xs: 0.75rem;
-  --ix-size-sm: 0.875rem;
-  --ix-size-md: 1rem;
-  --ix-size-lg: 1.125rem;
-  --ix-size-xl: 1.25rem;
-
-  --ix-line-height: 1.5;
-
-  --ix-space-sm: 0.5rem;
-  --ix-space-md: 1rem;
-  --ix-space-lg: 1.5rem;
-
-  --ix-radius:       ${t.radius};
-  --ix-radius-lg:    ${t.radiusLg};
-  --ix-badge-radius: ${t.badgeRadius};
-
-  --ix-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
-
-  --ix-gradient:    linear-gradient(to right, ${t.gradientStart}, ${t.gradientEnd});
-  --ix-gradient-bg: linear-gradient(to right, ${t.gradientStart}, ${t.gradientBgEnd});
-
-  --ix-skeleton-bg:      ${t.skeletonBg};
-  --ix-skeleton-shimmer: ${t.skeletonShimmer};
-}`;
-}
-
-// src/tools/generate-theme.ts
-var schema3 = z3.object({ prompt: z3.string().min(1) });
-function generateTheme(args) {
-  const parsed = schema3.safeParse(args);
-  if (!parsed.success) {
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify({
-            error: "Invalid input",
-            suggestion: "Expected { prompt: string }",
-            tokens_used: 2
-          })
-        }
-      ]
-    };
-  }
-  const { prompt } = parsed.data;
-  const tokens = resolveTokens(prompt.toLowerCase().trim());
-  return {
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify({
-          prompt,
-          primary: tokens.resolvedPrimary,
-          isDark: tokens.isDark,
-          css: buildCss(tokens),
-          tokens_used: 10
-        })
-      }
-    ]
-  };
-}
-
-// src/tools/check-a11y.ts
-import { parse as parse2 } from "node-html-parser";
-
-// src/utils/a11y-rules.ts
-function injectAttr(outerHTML, attr, value) {
-  return outerHTML.replace(/^(<[a-zA-Z][a-zA-Z0-9-]*)/, `$1 ${attr}="${value}"`);
-}
-function clip(str, max = 200) {
-  return str.length > max ? str.slice(0, max) + "..." : str;
-}
-function isDecorative(img) {
-  const role = img.getAttribute("role");
-  const ariaHidden = img.getAttribute("aria-hidden");
-  return role === "presentation" || role === "none" || ariaHidden === "true";
-}
-function findBrokenAriaRefs(el, attr, root) {
-  const val = el.getAttribute(attr);
-  if (!val?.trim()) return [];
-  return val.trim().split(/\s+/).filter((id) => !root.querySelector(`[id="${id}"]`));
-}
-function getVisibleText(el) {
-  if (el.getAttribute("aria-hidden") === "true") return "";
-  let result = "";
-  for (const child of el.childNodes) {
-    if (child.nodeType === 1) {
-      result += getVisibleText(child);
-    } else if (child.nodeType === 3) {
-      result += child.text ?? "";
-    }
-  }
-  return result;
-}
-function getAccessibleName(el, root) {
-  const text = getVisibleText(el).trim();
-  if (text) return text;
-  const ariaLabel = el.getAttribute("aria-label")?.trim();
-  if (ariaLabel) return ariaLabel;
-  const title = el.getAttribute("title")?.trim();
-  if (title) return title;
-  const childImg = el.querySelector("img");
-  const childAlt = childImg?.getAttribute("alt")?.trim();
-  if (childAlt) return childAlt;
-  const labelledBy = el.getAttribute("aria-labelledby");
-  if (labelledBy) {
-    const name = labelledBy.trim().split(/\s+/).map((id) => root.querySelector(`[id="${id}"]`)?.text.trim() ?? "").join(" ").trim();
-    if (name) return name;
-  }
-  return "";
-}
-function checkImages(root) {
-  const ruleName = "WCAG 1.1.1 Non-text Content";
-  const issues = [];
-  root.querySelectorAll("img").forEach((img) => {
-    const alt = img.getAttribute("alt");
-    const ariaLabel = img.getAttribute("aria-label")?.trim();
-    const labelledBy = img.getAttribute("aria-labelledby");
-    const hasAriaName = !!(ariaLabel || labelledBy);
-    if (alt === void 0) {
-      if (hasAriaName) {
-        issues.push({
-          type: "warning",
-          rule: ruleName,
-          element: clip(img.outerHTML),
-          message: "<img> uses aria-label/aria-labelledby but the alt attribute is recommended for broader screen reader compatibility",
-          fix: injectAttr(
-            img.outerHTML,
-            "alt",
-            ariaLabel ?? "[Describe the image]"
-          )
-        });
-      } else {
-        issues.push({
-          type: "error",
-          rule: ruleName,
-          element: clip(img.outerHTML),
-          message: "<img> is missing the alt attribute",
-          fix: injectAttr(img.outerHTML, "alt", "[Describe the image]")
-        });
-      }
-      return;
-    }
-    if (alt.trim() === "" && !isDecorative(img)) {
-      issues.push({
-        type: "warning",
-        rule: ruleName,
-        element: clip(img.outerHTML),
-        message: '<img> has an empty alt but is not marked as decorative - add role="presentation" or provide a description',
-        fix: injectAttr(img.outerHTML, "role", "presentation")
-      });
-    }
-  });
-  return { ruleName, issues };
-}
-function checkFormLabels(root) {
-  const ruleName = "WCAG 1.3.1 Form Labels";
-  const issues = [];
-  const UNLABELED_SKIP = /* @__PURE__ */ new Set([
-    "hidden",
-    "submit",
-    "reset",
-    "button",
-    "image"
-  ]);
-  for (const tag of ["input", "select", "textarea"]) {
-    root.querySelectorAll(tag).forEach((el) => {
-      if (tag === "input") {
-        const type = (el.getAttribute("type") ?? "text").toLowerCase();
-        if (UNLABELED_SKIP.has(type)) return;
-      }
-      const id = el.getAttribute("id");
-      const hasExplicit = id ? !!root.querySelector(`label[for="${id}"]`) : false;
-      const hasImplicit = !!el.closest("label");
-      const ariaLabel = el.getAttribute("aria-label")?.trim();
-      const ariaLabelledBy = el.getAttribute("aria-labelledby");
-      const hasTitle = !!el.getAttribute("title")?.trim();
-      if (!hasExplicit && !hasImplicit && !ariaLabel && !ariaLabelledBy && !hasTitle) {
-        issues.push({
-          type: "error",
-          rule: ruleName,
-          element: clip(el.outerHTML),
-          message: `<${tag}> is not associated with a <label> - use for/id, wrapping label, or aria-label`,
-          fix: id ? `<label for="${id}">[Label text]</label>
-${el.outerHTML}` : `<label>[Label text] ${el.outerHTML}</label>`
-        });
-        return;
-      }
-      if (ariaLabelledBy) {
-        const broken = findBrokenAriaRefs(el, "aria-labelledby", root);
-        if (broken.length > 0) {
-          issues.push({
-            type: "error",
-            rule: ruleName,
-            element: clip(el.outerHTML),
-            message: `<${tag}> aria-labelledby references non-existent element(s): ${broken.map((id2) => `#${id2}`).join(", ")}`,
-            fix: `Ensure element(s) with id="${broken.join('", "')}" exist in the DOM, or use aria-label instead`
-          });
-        }
-      }
-    });
-  }
-  root.querySelectorAll("fieldset").forEach((fieldset) => {
-    const legend = fieldset.querySelector("legend");
-    if (!legend || !legend.text.trim()) {
-      issues.push({
-        type: "error",
-        rule: ruleName,
-        element: "<fieldset>",
-        message: "<fieldset> must have a non-empty <legend> to group related form controls",
-        fix: `<fieldset>
-  <legend>[Group label]</legend>
-  ...
-</fieldset>`
-      });
-    }
-  });
-  return { ruleName, issues };
-}
-function checkEmptyLabels(root) {
-  const ruleName = "WCAG 2.4.6 Empty Labels";
-  const issues = [];
-  root.querySelectorAll("label").forEach((label) => {
-    const hasText = !!label.text.trim();
-    const hasAriaLabel = !!label.getAttribute("aria-label")?.trim();
-    if (!hasText && !hasAriaLabel) {
-      issues.push({
-        type: "warning",
-        rule: ruleName,
-        element: clip(label.outerHTML),
-        message: "<label> is empty and provides no accessible name for its control",
-        fix: label.outerHTML.replace("</label>", "[Label text]</label>")
-      });
-    }
-    const forAttr = label.getAttribute("for");
-    if (forAttr && !root.querySelector(`[id="${forAttr}"]`)) {
-      issues.push({
-        type: "error",
-        rule: ruleName,
-        element: clip(label.outerHTML),
-        message: `<label for="${forAttr}"> references id="${forAttr}" which does not exist in the DOM`,
-        fix: `Add id="${forAttr}" to the target form element, or correct the for attribute`
-      });
-    }
-  });
-  return { ruleName, issues };
-}
-function checkButtons(root) {
-  const ruleName = "WCAG 4.1.2 Button Names";
-  const issues = [];
-  root.querySelectorAll("button").forEach((button) => {
-    if (!getAccessibleName(button, root)) {
-      issues.push({
-        type: "error",
-        rule: ruleName,
-        element: clip(button.outerHTML),
-        message: "<button> has no accessible name - add text content, aria-label, or a child <img> with alt",
-        fix: injectAttr(button.outerHTML, "aria-label", "[Action description]")
-      });
-    }
-  });
-  return { ruleName, issues };
-}
-function checkLinks(root) {
-  const ruleName = "WCAG 2.4.4 Link Purpose";
-  const issues = [];
-  const VAGUE = /* @__PURE__ */ new Set([
-    "click here",
-    "here",
-    "read more",
-    "more",
-    "link",
-    "click",
-    "learn more",
-    "details",
-    "info"
-  ]);
-  root.querySelectorAll("a").forEach((link) => {
-    const name = getAccessibleName(link, root);
-    const href = link.getAttribute("href");
-    const isButtonRole = link.getAttribute("role") === "button";
-    if (!name) {
-      issues.push({
-        type: "error",
-        rule: ruleName,
-        element: clip(link.outerHTML),
-        message: "<a> has no accessible name - add text, aria-label, or a child <img> with alt",
-        fix: injectAttr(
-          link.outerHTML,
-          "aria-label",
-          "[Describe the link destination]"
-        )
-      });
-      return;
-    }
-    if (VAGUE.has(name.toLowerCase())) {
-      issues.push({
-        type: "warning",
-        rule: ruleName,
-        element: clip(link.outerHTML),
-        message: `<a> has non-descriptive text "${name}" - use aria-label to clarify the destination`,
-        fix: injectAttr(
-          link.outerHTML,
-          "aria-label",
-          "[Describe where this link goes]"
-        )
-      });
-    }
-    if (!href && !isButtonRole) {
-      issues.push({
-        type: "warning",
-        rule: ruleName,
-        element: clip(link.outerHTML),
-        message: "<a> has no href - use <button> for actions, or add a valid href",
-        fix: link.outerHTML.replace(/^<a\b/, '<a href="#"')
-      });
-    }
-  });
-  return { ruleName, issues };
-}
-function checkAriaStates(root) {
-  const ruleName = "WCAG 3.3.1 Error Identification";
-  const issues = [];
-  root.querySelectorAll("[aria-invalid]").forEach((el) => {
-    const invalidVal = el.getAttribute("aria-invalid");
-    const VALID_INVALID_VALUES = /* @__PURE__ */ new Set([
-      "false",
-      "true",
-      "grammar",
-      "spelling"
-    ]);
-    if (!VALID_INVALID_VALUES.has(invalidVal ?? "")) {
-      issues.push({
-        type: "warning",
-        rule: "WCAG 4.1.2 ARIA State Values",
-        element: clip(el.outerHTML),
-        message: `aria-invalid="${invalidVal}" is not valid - use "true", "false", "grammar", or "spelling"`,
-        fix: el.outerHTML.replace(
-          `aria-invalid="${invalidVal}"`,
-          'aria-invalid="true"'
-        )
-      });
-      return;
-    }
-    if (invalidVal === "true") {
-      const describedBy = el.getAttribute("aria-describedby");
-      if (!describedBy) {
-        issues.push({
-          type: "error",
-          rule: ruleName,
-          element: clip(el.outerHTML),
-          message: 'Element with aria-invalid="true" must have aria-describedby pointing to the error message element',
-          fix: injectAttr(el.outerHTML, "aria-describedby", "error-message-id")
-        });
-      } else {
-        const broken = findBrokenAriaRefs(el, "aria-describedby", root);
-        if (broken.length > 0) {
-          issues.push({
-            type: "error",
-            rule: ruleName,
-            element: clip(el.outerHTML),
-            message: `aria-describedby references non-existent element(s): ${broken.map((id) => `#${id}`).join(", ")}`,
-            fix: `Ensure element(s) with id="${broken.join('", "')}" exist in the DOM`
-          });
-        }
-      }
-    }
-  });
-  const BOOLEAN_ARIA_ATTRS = [
-    "aria-busy",
-    "aria-expanded",
-    "aria-selected",
-    "aria-pressed"
-  ];
-  for (const attr of BOOLEAN_ARIA_ATTRS) {
-    root.querySelectorAll(`[${attr}]`).forEach((el) => {
-      const val = el.getAttribute(attr);
-      if (val !== "true" && val !== "false") {
-        issues.push({
-          type: "warning",
-          rule: "WCAG 4.1.2 ARIA State Values",
-          element: clip(el.outerHTML),
-          message: `${attr} must be "true" or "false", got "${val}"`,
-          fix: el.outerHTML.replace(`${attr}="${val}"`, `${attr}="true"`)
-        });
-      }
-    });
-  }
-  root.querySelectorAll("[aria-checked]").forEach((el) => {
-    const val = el.getAttribute("aria-checked");
-    if (val !== "true" && val !== "false" && val !== "mixed") {
-      issues.push({
-        type: "warning",
-        rule: "WCAG 4.1.2 ARIA State Values",
-        element: clip(el.outerHTML),
-        message: `aria-checked must be "true", "false", or "mixed" (for tri-state), got "${val}"`,
-        fix: el.outerHTML.replace(
-          `aria-checked="${val}"`,
-          'aria-checked="false"'
-        )
-      });
-    }
-  });
-  const VALID_ARIA_LIVE = /* @__PURE__ */ new Set(["off", "polite", "assertive"]);
-  root.querySelectorAll("[aria-live]").forEach((el) => {
-    const val = el.getAttribute("aria-live") ?? "";
-    if (!VALID_ARIA_LIVE.has(val)) {
-      issues.push({
-        type: "warning",
-        rule: "WCAG 4.1.2 ARIA State Values",
-        element: clip(el.outerHTML),
-        message: `aria-live="${val}" is not valid - use "off", "polite", or "assertive"`,
-        fix: el.outerHTML.replace(`aria-live="${val}"`, 'aria-live="polite"')
-      });
-    }
-  });
-  return { ruleName, issues };
-}
-function checkDuplicateIds(root) {
-  const ruleName = "WCAG 4.1.1 Parsing";
-  const issues = [];
-  const seen = /* @__PURE__ */ new Map();
-  root.querySelectorAll("[id]").forEach((el) => {
-    const id = el.getAttribute("id");
-    if (id !== void 0 && id.trim() === "") {
-      issues.push({
-        type: "error",
-        rule: ruleName,
-        element: clip(el.outerHTML),
-        message: 'id="" is an empty ID - IDs must have a non-empty value',
-        fix: el.outerHTML.replace('id=""', 'id="[unique-id]"')
-      });
-      return;
-    }
-    if (id) seen.set(id, (seen.get(id) ?? 0) + 1);
-  });
-  seen.forEach((count, id) => {
-    if (count > 1) {
-      issues.push({
-        type: "error",
-        rule: ruleName,
-        element: `id="${id}"`,
-        message: `id="${id}" is used ${count} times - IDs must be unique within a document`,
-        fix: `Keep one element with id="${id}" and rename all duplicates to unique IDs`
-      });
-    }
-  });
-  return { ruleName, issues };
-}
-function checkTabIndex(root) {
-  const ruleName = "WCAG 2.1.1 Keyboard";
-  const issues = [];
-  root.querySelectorAll("[tabindex]").forEach((el) => {
-    const raw = el.getAttribute("tabindex") ?? "";
-    const val = parseInt(raw, 10);
-    if (isNaN(val)) {
-      issues.push({
-        type: "warning",
-        rule: ruleName,
-        element: clip(el.outerHTML),
-        message: `tabindex="${raw}" is not a valid integer`,
-        fix: el.outerHTML.replace(`tabindex="${raw}"`, 'tabindex="0"')
-      });
-      return;
-    }
-    if (val > 0) {
-      issues.push({
-        type: "warning",
-        rule: ruleName,
-        element: clip(el.outerHTML),
-        message: `tabindex="${val}" disrupts natural tab order - use tabindex="0" or rely on DOM order`,
-        fix: el.outerHTML.replace(`tabindex="${val}"`, 'tabindex="0"')
-      });
-    }
-  });
-  return { ruleName, issues };
-}
-function checkHeadings(root) {
-  const ruleName = "WCAG 2.4.6 Heading Hierarchy";
-  const issues = [];
-  const headings = root.querySelectorAll("h1, h2, h3, h4, h5, h6");
-  let lastLevel = 0;
-  let h1Count = 0;
-  headings.forEach((h) => {
-    const tag = h.tagName.toLowerCase();
-    const level = parseInt(h.tagName.slice(1), 10);
-    if (!h.text.trim()) {
-      issues.push({
-        type: "error",
-        rule: ruleName,
-        element: clip(h.outerHTML),
-        message: `<${tag}> is empty - headings must have descriptive text`,
-        fix: `<${tag}>[Heading text]</${tag}>`
-      });
-    }
-    if (level === 1) h1Count++;
-    if (lastLevel > 0 && level > lastLevel + 1) {
-      issues.push({
-        type: "warning",
-        rule: ruleName,
-        element: clip(h.outerHTML),
-        message: `Heading skips from h${lastLevel} to h${level} - use h${lastLevel + 1} to maintain document outline`,
-        fix: `<h${lastLevel + 1}>${h.text.trim()}</h${lastLevel + 1}>`
-      });
-    }
-    lastLevel = level;
-  });
-  if (h1Count > 1) {
-    issues.push({
-      type: "warning",
-      rule: ruleName,
-      element: "h1",
-      message: `${h1Count} <h1> elements found - a page should have exactly one <h1>`,
-      fix: "Demote additional <h1> elements to <h2> or lower"
-    });
-  }
-  return { ruleName, issues };
-}
-function checkTables(root) {
-  const ruleName = "WCAG 1.3.1 Table Structure";
-  const issues = [];
-  root.querySelectorAll("table").forEach((table) => {
-    const role = table.getAttribute("role");
-    if (role === "presentation" || role === "none") return;
-    const caption = table.querySelector("caption");
-    const ariaLabel = table.getAttribute("aria-label");
-    const ariaLabelledBy = table.getAttribute("aria-labelledby");
-    if (!caption && !ariaLabel && !ariaLabelledBy) {
-      issues.push({
-        type: "warning",
-        rule: ruleName,
-        element: "<table>",
-        message: "<table> has no caption, aria-label, or aria-labelledby - screen readers cannot identify its purpose",
-        fix: injectAttr("<table>", "aria-label", "[Describe the table]")
-      });
-    }
-    if (caption && !caption.text.trim()) {
-      issues.push({
-        type: "warning",
-        rule: ruleName,
-        element: clip(caption.outerHTML),
-        message: "<caption> is empty - provide a meaningful description of the table",
-        fix: caption.outerHTML.replace(
-          "</caption>",
-          "[Table description]</caption>"
-        )
-      });
-    }
-    table.querySelectorAll("th").forEach((th) => {
-      if (!th.getAttribute("scope")) {
-        issues.push({
-          type: "warning",
-          rule: ruleName,
-          element: clip(th.outerHTML),
-          message: '<th> is missing the scope attribute - use scope="col" for column headers or scope="row" for row headers',
-          fix: injectAttr(th.outerHTML, "scope", "col")
-        });
-      }
-    });
-  });
-  return { ruleName, issues };
-}
-function checkDialogs(root) {
-  const ruleName = "WCAG 4.1.2 Dialog Accessibility";
-  const issues = [];
-  root.querySelectorAll("dialog").forEach((dialog) => {
-    const id = dialog.getAttribute("id");
-    const ariaLabel = dialog.getAttribute("aria-label");
-    const ariaLabelledBy = dialog.getAttribute("aria-labelledby");
-    if (!id) {
-      issues.push({
-        type: "warning",
-        rule: ruleName,
-        element: "<dialog>",
-        message: '<dialog> has no id - required by the ignix-lite button[onclick="dialogId.showModal()"] pattern',
-        fix: injectAttr("<dialog>", "id", "dialog-id")
-      });
-    }
-    if (!ariaLabel && !ariaLabelledBy) {
-      issues.push({
-        type: "warning",
-        rule: ruleName,
-        element: "<dialog>",
-        message: "<dialog> has no accessible name - add aria-labelledby pointing to a heading inside, or aria-label",
-        fix: id ? `<dialog id="${id}" aria-labelledby="dialog-title">...</dialog>` : `<dialog aria-label="[Dialog purpose]">...</dialog>`
-      });
-    } else if (ariaLabelledBy) {
-      const broken = findBrokenAriaRefs(dialog, "aria-labelledby", root);
-      if (broken.length > 0) {
-        issues.push({
-          type: "error",
-          rule: ruleName,
-          element: "<dialog>",
-          message: `dialog aria-labelledby references non-existent element(s): ${broken.map((id2) => `#${id2}`).join(", ")}`,
-          fix: `Ensure element(s) with id="${broken.join('", "')}" exist inside the dialog`
-        });
-      }
-    }
-  });
-  return { ruleName, issues };
-}
-function checkRoles(root) {
-  const ruleName = "WCAG 4.1.2 ARIA Role Requirements";
-  const issues = [];
-  const NATIVELY_INTERACTIVE = /* @__PURE__ */ new Set([
-    "a",
-    "button",
-    "input",
-    "select",
-    "textarea",
-    "details",
-    "summary"
-  ]);
-  root.querySelectorAll('[role="button"]').forEach((el) => {
-    const tag = el.tagName.toLowerCase();
-    const tabIndex = el.getAttribute("tabindex");
-    if (!NATIVELY_INTERACTIVE.has(tag) && tabIndex !== "0") {
-      issues.push({
-        type: "error",
-        rule: ruleName,
-        element: clip(el.outerHTML),
-        message: 'Element with role="button" must have tabindex="0" to be keyboard-accessible',
-        fix: injectAttr(el.outerHTML, "tabindex", "0")
-      });
-    }
-  });
-  for (const role of [
-    "checkbox",
-    "radio",
-    "menuitemcheckbox",
-    "menuitemradio"
-  ]) {
-    root.querySelectorAll(`[role="${role}"]`).forEach((el) => {
-      if (!el.getAttribute("aria-checked")) {
-        issues.push({
-          type: "error",
-          rule: ruleName,
-          element: clip(el.outerHTML),
-          message: `role="${role}" requires aria-checked attribute (values: "true", "false"${role === "checkbox" ? ', "mixed"' : ""})`,
-          fix: injectAttr(el.outerHTML, "aria-checked", "false")
-        });
-      }
-    });
-  }
-  root.querySelectorAll('[role="combobox"]').forEach((el) => {
-    if (!el.getAttribute("aria-expanded")) {
-      issues.push({
-        type: "error",
-        rule: ruleName,
-        element: clip(el.outerHTML),
-        message: 'role="combobox" requires aria-expanded attribute',
-        fix: injectAttr(el.outerHTML, "aria-expanded", "false")
-      });
-    }
-  });
-  for (const role of ["tab", "option", "treeitem", "gridcell"]) {
-    root.querySelectorAll(`[role="${role}"]`).forEach((el) => {
-      if (!el.getAttribute("aria-selected")) {
-        issues.push({
-          type: "error",
-          rule: ruleName,
-          element: clip(el.outerHTML),
-          message: `role="${role}" requires aria-selected attribute`,
-          fix: injectAttr(el.outerHTML, "aria-selected", "false")
-        });
-      }
-    });
-  }
-  root.querySelectorAll('[role="slider"]').forEach((el) => {
-    const required = ["aria-valuenow", "aria-valuemin", "aria-valuemax"];
-    const missing = required.filter((attr) => !el.getAttribute(attr));
-    if (missing.length > 0) {
-      issues.push({
-        type: "error",
-        rule: ruleName,
-        element: clip(el.outerHTML),
-        message: `role="slider" is missing required attributes: ${missing.join(", ")}`,
-        fix: 'Add aria-valuenow="50" aria-valuemin="0" aria-valuemax="100" to the element'
-      });
-    }
-  });
-  root.querySelectorAll('[role="progressbar"]').forEach((el) => {
-    if (!el.getAttribute("aria-valuenow") && !el.getAttribute("aria-valuetext")) {
-      issues.push({
-        type: "warning",
-        rule: ruleName,
-        element: clip(el.outerHTML),
-        message: 'role="progressbar" should have aria-valuenow or aria-valuetext to communicate current progress',
-        fix: injectAttr(el.outerHTML, "aria-valuenow", "0")
-      });
-    }
-  });
-  root.querySelectorAll('[role="listbox"]').forEach((el) => {
-    if (!getAccessibleName(el, root)) {
-      issues.push({
-        type: "warning",
-        rule: ruleName,
-        element: clip(el.outerHTML),
-        message: 'role="listbox" should have an accessible name via aria-label or aria-labelledby',
-        fix: injectAttr(
-          el.outerHTML,
-          "aria-label",
-          "[Describe the list options]"
-        )
-      });
-    }
-  });
-  return { ruleName, issues };
-}
-function checkAutocomplete(root) {
-  const ruleName = "WCAG 1.3.5 Input Purpose";
-  const issues = [];
-  const TYPE_AUTOCOMPLETE = {
-    email: "email",
-    tel: "tel",
-    url: "url"
-  };
-  root.querySelectorAll("input").forEach((input) => {
-    const type = (input.getAttribute("type") ?? "text").toLowerCase();
-    const expected = TYPE_AUTOCOMPLETE[type];
-    if (expected && !input.getAttribute("autocomplete")) {
-      issues.push({
-        type: "warning",
-        rule: ruleName,
-        element: clip(input.outerHTML),
-        message: `<input type="${type}"> should have autocomplete="${expected}" to assist users with autofill`,
-        fix: injectAttr(input.outerHTML, "autocomplete", expected)
-      });
-    }
-    if (type === "password" && !input.getAttribute("autocomplete")) {
-      issues.push({
-        type: "warning",
-        rule: ruleName,
-        element: clip(input.outerHTML),
-        message: '<input type="password"> should have autocomplete="current-password" or autocomplete="new-password"',
-        fix: injectAttr(input.outerHTML, "autocomplete", "current-password")
-      });
-    }
-  });
-  return { ruleName, issues };
-}
-function checkFocusStyle(root) {
-  const ruleName = "WCAG 2.4.7 Focus Visible";
-  const issues = [];
-  const KILLS_FOCUS = [
-    /outline\s*:\s*none/i,
-    /outline\s*:\s*0(?:px)?/i,
-    /outline-width\s*:\s*0/i
-  ];
-  root.querySelectorAll("[style]").forEach((el) => {
-    const style = el.getAttribute("style") ?? "";
-    if (KILLS_FOCUS.some((rx) => rx.test(style))) {
-      issues.push({
-        type: "warning",
-        rule: ruleName,
-        element: clip(el.outerHTML),
-        message: "Inline style removes the focus outline - keyboard users cannot see the focus indicator",
-        fix: el.outerHTML.replace(/outline\s*:\s*(none|0(?:px)?)\s*;?/gi, "").replace(/outline-width\s*:\s*0\s*;?/gi, "")
-      });
-    }
-  });
-  return { ruleName, issues };
-}
-function checkLang(root) {
-  const ruleName = "WCAG 3.1.1 Language of Page";
-  const issues = [];
-  const htmlEl = root.querySelector("html");
-  if (htmlEl && !htmlEl.getAttribute("lang")?.trim()) {
-    issues.push({
-      type: "error",
-      rule: ruleName,
-      element: "<html>",
-      message: "<html> is missing the lang attribute - screen readers need this to select the correct voice/language",
-      fix: '<html lang="en">'
-    });
-  }
-  return { ruleName, issues };
-}
-
-// src/tools/check-a11y.ts
-var RULE_CONFIDENCES = {
-  "WCAG 1.1.1 Non-text Content": { error: 0.99, warning: 0.8 },
-  "WCAG 1.3.1 Form Labels": { error: 0.98, warning: 0.78 },
-  "WCAG 2.4.6 Empty Labels": { error: 0.95, warning: 0.75 },
-  "WCAG 4.1.2 Button Names": { error: 0.99, warning: 0.8 },
-  "WCAG 2.4.4 Link Purpose": { error: 0.97, warning: 0.75 },
-  "WCAG 3.3.1 Error Identification": { error: 0.98, warning: 0.75 },
-  "WCAG 4.1.2 ARIA State Values": { error: 0.96, warning: 0.75 },
-  "WCAG 4.1.1 Parsing": { error: 0.99, warning: 0.8 },
-  "WCAG 2.1.1 Keyboard": { error: 0.95, warning: 0.75 },
-  "WCAG 2.4.6 Heading Hierarchy": { error: 0.95, warning: 0.75 },
-  "WCAG 1.3.1 Table Structure": { error: 0.97, warning: 0.75 },
-  "WCAG 4.1.2 Dialog Accessibility": { error: 0.98, warning: 0.75 },
-  "WCAG 4.1.2 ARIA Role Requirements": { error: 0.98, warning: 0.75 },
-  "WCAG 1.3.5 Input Purpose": { error: 0.95, warning: 0.75 },
-  "WCAG 2.4.7 Focus Visible": { error: 0.95, warning: 0.75 },
-  "WCAG 3.1.1 Language of Page": { error: 0.99, warning: 0.8 }
-};
-function getConfidenceForRule(ruleName, type) {
-  const conf = RULE_CONFIDENCES[ruleName];
-  if (conf) {
-    return type === "error" ? conf.error : conf.warning;
-  }
-  return type === "error" ? 0.98 : 0.75;
-}
-function computeScore(issues) {
-  const errors = issues.filter((i) => i.type === "error").length;
-  const warnings = issues.filter((i) => i.type === "warning").length;
-  return Math.max(0, 100 - errors * 10 - warnings * 3);
-}
-function getPassingRules(results) {
-  return results.filter((r) => r.issues.length === 0).map((r) => r.ruleName);
-}
-function checkA11y(html) {
-  const root = parse2(html);
-  const results = [
-    checkImages(root),
-    checkFormLabels(root),
-    checkEmptyLabels(root),
-    checkButtons(root),
-    checkLinks(root),
-    checkAriaStates(root),
-    checkDuplicateIds(root),
-    checkTabIndex(root),
-    checkHeadings(root),
-    checkTables(root),
-    checkDialogs(root),
-    checkRoles(root),
-    checkAutocomplete(root),
-    checkFocusStyle(root),
-    checkLang(root)
-  ];
-  const rawIssues = results.flatMap((r) => r.issues);
-  const issues = rawIssues.map((i) => ({
-    ...i,
-    confidence: getConfidenceForRule(i.rule, i.type)
-  }));
-  const passes = getPassingRules(results);
-  const score = computeScore(issues);
-  return {
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify({
-          score,
-          passes,
-          issues,
-          wcag: "AA",
-          tokens_used: Math.min(60, 20 + issues.length * 3)
-        })
-      }
-    ]
-  };
+var apiPath = path.resolve(__dirname, "../../../api-full.txt");
+if (!existsSync(apiPath)) {
+  apiPath = path.resolve(__dirname, "../../../../api-full.txt");
 }
+var apiContext = readFileSync(apiPath, "utf8");
 
 // src/server.ts
+import {
+  listComponents,
+  getManifest,
+  getEmmet,
+  validateHtml,
+  howToBuild,
+  generateTheme,
+  auditA11y,
+  preview,
+  getTokenSummary,
+  recordCall,
+  createHandoff,
+  applyHandoff
+} from "@mindfiredigital/ignix-lite-engine";
 var server = new Server(
   {
     name: "ignix-lite",
@@ -2052,35 +133,176 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
         },
         required: ["html"]
       }
+    },
+    {
+      name: "preview",
+      description: "Render visual preview to PNG",
+      inputSchema: {
+        type: "object",
+        properties: {
+          input: {
+            type: "string"
+          },
+          options: {
+            type: "object",
+            properties: {
+              width: {
+                type: "number"
+              },
+              theme: {
+                type: "string"
+              },
+              scale: {
+                type: "number"
+              }
+            }
+          }
+        },
+        required: ["input"]
+      }
+    },
+    {
+      name: "get_token_summary",
+      description: "Get session token summary and budget details",
+      inputSchema: {
+        type: "object",
+        properties: {
+          context_window: {
+            type: "number",
+            description: "Optional model context window size"
+          }
+        }
+      }
+    },
+    {
+      name: "create_handoff",
+      description: "Create multi-agent handoff snapshot",
+      inputSchema: {
+        type: "object",
+        properties: {
+          rendered_html: {
+            type: "string"
+          },
+          metadata: {
+            type: "object"
+          }
+        },
+        required: ["rendered_html"]
+      }
+    },
+    {
+      name: "apply_handoff",
+      description: "Apply changes to an existing handoff snapshot",
+      inputSchema: {
+        type: "object",
+        properties: {
+          handoff_id: {
+            type: "string"
+          },
+          changes: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                selector: {
+                  type: "string"
+                },
+                action: {
+                  type: "string",
+                  enum: ["update", "add", "remove"]
+                },
+                emmet: {
+                  type: "string"
+                },
+                html: {
+                  type: "string"
+                }
+              },
+              required: ["selector", "action"]
+            }
+          }
+        },
+        required: ["handoff_id", "changes"]
+      }
     }
   ]
 }));
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
   const { name, arguments: args } = request.params;
+  console.error("TOOL CALLED:", name);
+  let response;
   switch (name) {
     case "list_components":
-      return listComponents();
+      response = listComponents();
+      break;
     case "get_manifest":
-      return getManifest(args);
+      response = getManifest(args);
+      break;
     case "get_emmet":
-      return getEmmet(args);
+      response = getEmmet(args);
+      break;
     case "validate": {
       const validateArgs = args;
-      return validate(validateArgs.html ?? "");
+      const result = validateHtml(validateArgs.html ?? "");
+      response = {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              ...result,
+              tokens_used: 50
+            })
+          }
+        ]
+      };
+      break;
     }
     case "how_to_build": {
       const intentArgs = args;
-      return await howToBuild(intentArgs.description ?? "");
-    }
-    case "generate_theme": {
-      return generateTheme(args);
+      response = await howToBuild(intentArgs.description ?? "");
+      break;
     }
+    case "generate_theme":
+      response = generateTheme(args);
+      break;
     case "check_a11y": {
       const a11yArgs = args;
-      return checkA11y(a11yArgs.html ?? "");
+      const result = auditA11y(a11yArgs.html ?? "");
+      response = {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              ...result,
+              tokens_used: Math.min(60, 20 + result.issues.length * 3)
+            })
+          }
+        ]
+      };
+      break;
+    }
+    case "preview": {
+      const previewArgs = args;
+      response = await preview(previewArgs);
+      break;
+    }
+    case "get_token_summary": {
+      const tokenArgs = args;
+      response = getTokenSummary(tokenArgs);
+      break;
+    }
+    case "create_handoff": {
+      const handoffArgs = args;
+      response = createHandoff(handoffArgs);
+      break;
+    }
+    case "apply_handoff": {
+      const applyArgs = args;
+      response = applyHandoff(applyArgs);
+      break;
     }
     default:
-      return {
+      response = {
         content: [
           {
             type: "text",
@@ -2090,14 +312,25 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           }
         ]
       };
+      break;
+  }
+  if (response && response.content && response.content[0] && response.content[0].text) {
+    try {
+      const parsed = JSON.parse(response.content[0].text);
+      if (parsed && typeof parsed.tokens_used === "number") {
+        recordCall(name, parsed.tokens_used);
+      }
+    } catch {
+    }
   }
+  return response;
 });
 async function start() {
-  console.log("API loaded");
-  console.log(apiContext.length);
+  console.error("API loaded");
+  console.error(apiContext.length);
   const transport = new StdioServerTransport();
   await server.connect(transport);
-  console.log("Ignix MCP started");
+  console.error("Ignix MCP started");
 }
 start();
 //# sourceMappingURL=server.js.map