@axis-ds/mcp 1.1.5 → 1.2.1

package/README.md

@@ -25,6 +25,19 @@ Claude Desktop 또는 기타 MCP 호환 클라이언트에서 설정:
 }
 ```
 
+## 브랜드 도구
+
+대상 프로젝트에 설치된 `@axis-ds/tokens`(1.3.0 이상)의 브랜드를 읽습니다. 패키지에 데이터를 번들하지 않으며, CLI `axis theme list` · `axis theme info` 와 같은 내용을 돌려줍니다.
+
+| 도구 | 인자 | 응답 |
+|------|------|------|
+| `axis.list_brands` | `targetDir?` | 브랜드 이름 · 설명 · 테마 · import 경로 |
+| `axis.get_brand` | `name`, `targetDir?` | import 경로 · Provider 예시(`defaultBrand`) · 주요 토큰(라이트 · 다크) · 보정 내역(a11y 메타) |
+
+- `targetDir` 를 주지 않으면 서버의 현재 디렉터리를 봅니다.
+- `@axis-ds/tokens` 가 없거나 1.3.0 미만이거나 빌드 산출물이 없으면 오류(`isError`)가 아니라 설치 · 업그레이드 안내를 돌려줍니다. 빈 목록으로 답하지 않습니다.
+- 프로젝트에 적용하는 일(import 추가 · `axis.config.json` 의 `brand`)은 CLI `axis theme add <brand>` 가 맡습니다.
+
 ## 문서
 
 자세한 사용법은 [AXIS Design System 문서](https://axis.minu.best)를 참고하세요.

package/dist/index.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
+import { createRequire as createRequire2 } from "module";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
@@ -64,10 +65,10 @@ function listTokens(category) {
   }
   return registry.tokens;
 }
-function getToken(path4) {
+function getToken(path5) {
   const registry = getRegistry();
   return registry.tokens.find(
-    (t) => t.path.toLowerCase() === path4.toLowerCase()
+    (t) => t.path.toLowerCase() === path5.toLowerCase()
   );
 }
 function getComponentStats() {
@@ -151,11 +152,11 @@ function handleGetComponent(params) {
   return component;
 }
 function handleGetToken(params) {
-  const { path: path4 } = params;
-  if (!path4 || path4.trim() === "") {
+  const { path: path5 } = params;
+  if (!path5 || path5.trim() === "") {
     throw new Error("\uD1A0\uD070 \uACBD\uB85C(path)\uB294 \uD544\uC218\uC785\uB2C8\uB2E4.");
   }
-  const token = getToken(path4);
+  const token = getToken(path5);
   if (!token) {
     return null;
   }
@@ -2068,6 +2069,423 @@ function formatSaveResult(result) {
 import fetch from "node-fetch";
 import fs3 from "fs-extra";
 import path3 from "path";
+
+// src/tools/brand-core.ts
+import { existsSync as existsSync4, readFileSync as readFileSync5, statSync } from "fs";
+import { createRequire } from "module";
+import { dirname as dirname4, join as join4, relative, resolve as resolve2, sep } from "path";
+var TOKENS_PACKAGE = "@axis-ds/tokens";
+var MIN_BRAND_TOKENS_VERSION = "1.3.0";
+var KEY_TOKENS = [
+  "--primary",
+  "--primary-foreground",
+  "--background",
+  "--foreground",
+  "--ring",
+  "--radius",
+  "--axis-surface-default",
+  "--axis-text-primary",
+  "--axis-text-brand",
+  "--axis-button-bg-default",
+  "--axis-border-focus",
+  "--axis-font-family-sans"
+];
+var BRAND_ADJUSTMENT_REFERENCE = "WI-0025 PRD \uBD80\uB85D B (docs/workitems/WI-0025-brand-theme/prd.md)";
+function readJsonFile(file) {
+  return JSON.parse(readFileSync5(file, "utf8"));
+}
+function errorCode(err) {
+  return typeof err === "object" && err !== null && "code" in err ? String(err.code) : void 0;
+}
+function findTokensPackageJson(baseDir) {
+  let dir = resolve2(baseDir);
+  for (; ; ) {
+    const candidate = join4(dir, "node_modules", TOKENS_PACKAGE, "package.json");
+    if (existsSync4(candidate)) return candidate;
+    const parent = dirname4(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
+function projectRequire(baseDir) {
+  return createRequire(join4(resolve2(baseDir), "package.json"));
+}
+function tokensSpecifier(subpath) {
+  return `${TOKENS_PACKAGE}/${subpath.replace(/^\.\//, "")}`;
+}
+function resolveTokens(baseDir) {
+  const pkgJson = findTokensPackageJson(baseDir);
+  if (!pkgJson) return { status: "not-installed" };
+  const pkg = readJsonFile(pkgJson);
+  const version = typeof pkg.version === "string" ? pkg.version : void 0;
+  try {
+    const indexPath = projectRequire(baseDir).resolve(tokensSpecifier("./brands"));
+    return { status: "ok", version, indexPath };
+  } catch (err) {
+    const code = errorCode(err);
+    if (code === "ERR_PACKAGE_PATH_NOT_EXPORTED") return { status: "unsupported", version };
+    if (code === "MODULE_NOT_FOUND") return { status: "not-built", version };
+    throw err;
+  }
+}
+function brandImportPath(entry) {
+  return tokensSpecifier(entry.css);
+}
+var GLOBAL_CSS_CANDIDATES = ["app/globals.css", "src/app/globals.css", "globals.css"];
+function isFile(file) {
+  try {
+    return statSync(file).isFile();
+  } catch {
+    return false;
+  }
+}
+function findGlobalCss(baseDir, config) {
+  const root = resolve2(baseDir);
+  const result = {};
+  const configured = config?.globalCss;
+  if (typeof configured === "string" && configured.trim() !== "") {
+    const file = resolve2(root, configured);
+    if (isFile(file)) return { path: file };
+    result.configuredMissing = configured;
+  }
+  for (const candidate of GLOBAL_CSS_CANDIDATES) {
+    const file = join4(root, candidate);
+    if (isFile(file)) {
+      result.path = file;
+      break;
+    }
+  }
+  return result;
+}
+function findBrandImports(css) {
+  const names = [];
+  const pattern = /@import\s+(?:url\(\s*)?["']?@axis-ds\/tokens\/css\/brands\/([a-z][a-z0-9-]*)(?:\.css)?["']?\s*\)?\s*(?=[;\s]|$)/g;
+  for (const m of stripComments(css).matchAll(pattern)) {
+    names.push(m[1]);
+  }
+  return names;
+}
+var AXIS_CONFIG_FILE_NAME = "axis.config.json";
+function readBrandConfig(baseDir) {
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync5(join4(resolve2(baseDir), AXIS_CONFIG_FILE_NAME), "utf8"));
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return null;
+  return parsed;
+}
+function inspectBrandImport(baseDir) {
+  const config = readBrandConfig(baseDir);
+  const brand = config?.brand;
+  if (typeof brand !== "string" || brand.trim() === "") return null;
+  const root = resolve2(baseDir);
+  const location = findGlobalCss(root, config);
+  const base = { brand };
+  if (location.configuredMissing !== void 0) base.configuredMissing = location.configuredMissing;
+  if (!location.path) {
+    return { ...base, state: "css-missing", imports: [] };
+  }
+  const cssFile = relative(root, location.path).split(sep).join("/");
+  const imports = [...new Set(findBrandImports(readFileSync5(location.path, "utf8")))];
+  let state;
+  if (imports.includes(brand)) state = "match";
+  else if (imports.length === 0) state = "import-missing";
+  else state = "other-brand";
+  return { ...base, state, cssFile, imports };
+}
+function isMissingBuildFile(err) {
+  const code = errorCode(err);
+  return code === "MODULE_NOT_FOUND" || code === "ENOENT";
+}
+function readBrandIndex(indexPath) {
+  const data = readJsonFile(indexPath);
+  if (!Array.isArray(data.brands)) {
+    throw new Error(`${indexPath}: "brands" \uBC30\uC5F4\uC774 \uC5C6\uC2B5\uB2C8\uB2E4`);
+  }
+  return data.brands;
+}
+function readSummary(baseDir, entry) {
+  const metaPath = projectRequire(baseDir).resolve(tokensSpecifier(entry.meta));
+  const meta = readJsonFile(metaPath);
+  return {
+    name: entry.name,
+    description: typeof meta.description === "string" ? meta.description : "",
+    themes: Array.isArray(meta.themes) ? meta.themes.map(String) : [],
+    a11y: typeof meta.a11y === "object" && meta.a11y !== null ? meta.a11y : {},
+    importPath: brandImportPath(entry)
+  };
+}
+function listBrands(baseDir) {
+  const tokens = resolveTokens(baseDir);
+  if (tokens.status !== "ok" || !tokens.indexPath) {
+    return { status: tokens.status, version: tokens.version, brands: [] };
+  }
+  const entries = readBrandIndex(tokens.indexPath);
+  let brands;
+  try {
+    brands = entries.map((entry) => readSummary(baseDir, entry));
+  } catch (err) {
+    if (isMissingBuildFile(err)) return { status: "not-built", version: tokens.version, brands: [] };
+    throw err;
+  }
+  return { status: "ok", version: tokens.version, brands };
+}
+function stripComments(css) {
+  return css.replace(/\/\*[\s\S]*?\*\//g, "");
+}
+function parseDeclarations(body) {
+  const out = {};
+  for (const m of body.matchAll(/(--[A-Za-z0-9_-]+)\s*:\s*([^;]+);/g)) {
+    out[m[1]] = m[2].trim();
+  }
+  return out;
+}
+function isDarkSelector(selector) {
+  return /\.dark\b/.test(selector) || /\[data-theme=["']?dark["']?\]/.test(selector);
+}
+function parseBrandCss(css, name) {
+  const result = { light: {}, dark: {} };
+  let lightFound = false;
+  let darkFound = false;
+  const brandAttr = new RegExp(`\\[data-brand=["']?${name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}["']?\\]`);
+  for (const m of stripComments(css).matchAll(/([^{}]+)\{([^{}]*)\}/g)) {
+    const selectors = m[1].split(",").map((s) => s.trim());
+    if (!selectors.some((s) => brandAttr.test(s))) continue;
+    if (selectors.some(isDarkSelector)) {
+      if (!darkFound) {
+        result.dark = parseDeclarations(m[2]);
+        darkFound = true;
+      }
+    } else if (!lightFound) {
+      result.light = parseDeclarations(m[2]);
+      lightFound = true;
+    }
+  }
+  return result;
+}
+function pickKeyTokens(decls) {
+  const out = {};
+  for (const key of KEY_TOKENS) {
+    if (Object.prototype.hasOwnProperty.call(decls, key)) out[key] = decls[key];
+  }
+  return out;
+}
+function providerExample(name) {
+  return [
+    'import { ThemeProvider } from "@axis-ds/theme";',
+    "",
+    `<ThemeProvider defaultBrand="${name}">{children}</ThemeProvider>`
+  ].join("\n");
+}
+function getBrand(baseDir, name) {
+  const tokens = resolveTokens(baseDir);
+  if (tokens.status !== "ok" || !tokens.indexPath) {
+    return { status: tokens.status, version: tokens.version, brand: null, available: [] };
+  }
+  const entries = readBrandIndex(tokens.indexPath);
+  const available = entries.map((e) => e.name);
+  const entry = entries.find((e) => e.name === name);
+  if (!entry) {
+    return { status: "ok", version: tokens.version, brand: null, available };
+  }
+  let summary;
+  let parsed;
+  try {
+    summary = readSummary(baseDir, entry);
+    const cssPath = projectRequire(baseDir).resolve(summary.importPath);
+    parsed = parseBrandCss(readFileSync5(cssPath, "utf8"), name);
+  } catch (err) {
+    if (isMissingBuildFile(err)) return { status: "not-built", version: tokens.version, brand: null, available: [] };
+    throw err;
+  }
+  return {
+    status: "ok",
+    version: tokens.version,
+    available,
+    brand: {
+      ...summary,
+      tokens: { light: pickKeyTokens(parsed.light), dark: pickKeyTokens(parsed.dark) },
+      providerExample: providerExample(name),
+      adjustments: { a11y: summary.a11y, reference: BRAND_ADJUSTMENT_REFERENCE }
+    }
+  };
+}
+
+// src/tools/tailwind-core.ts
+import { existsSync as existsSync5, readFileSync as readFileSync6 } from "fs";
+import { join as join5, resolve as resolve3 } from "path";
+function hasDependency(pkg, name) {
+  for (const field of ["dependencies", "devDependencies"]) {
+    const deps = pkg[field];
+    if (typeof deps === "object" && deps !== null && name in deps) {
+      return String(deps[name]);
+    }
+  }
+  return void 0;
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var VERSION = String.raw`v?(\d+)(?:\.(\d+|[xX*]))?(?:\.(\d+|[xX*]))?(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?`;
+function versionParts(token) {
+  const m = new RegExp(`^${VERSION}$`).exec(token);
+  if (!m) return void 0;
+  if (/^v?0\.0\.0-/.test(token)) return void 0;
+  return { major: Number(m[1]), minor: m[2], patch: m[3] };
+}
+var isWild = (part) => part === void 0 || /^[xX*]$/.test(part);
+function comparatorBounds(op, v) {
+  switch (op) {
+    case ">=":
+      return { lower: v.major };
+    case ">":
+      return { lower: isWild(v.minor) ? v.major + 1 : v.major };
+    case "<=":
+      return { upper: v.major };
+    case "<": {
+      const zeroOrWild = (part) => isWild(part) || Number(part) === 0;
+      return { upper: zeroOrWild(v.minor) && zeroOrWild(v.patch) ? v.major - 1 : v.major };
+    }
+    default:
+      return { lower: v.major, upper: v.major };
+  }
+}
+function tailwindMajorBounds(range) {
+  const r = range.trim();
+  if (r === "" || r.includes("||")) return void 0;
+  const simple = new RegExp(`^(?:\\^|~|=)?\\s*(${VERSION})$`).exec(r);
+  if (simple) {
+    const v = versionParts(simple[1]);
+    return v ? { lower: v.major, upper: v.major } : void 0;
+  }
+  const hyphen = new RegExp(`^(${VERSION})\\s+-\\s+(${VERSION})$`).exec(r);
+  if (hyphen) {
+    const tokens2 = r.split(/\s+-\s+/);
+    const a = versionParts(tokens2[0]);
+    const b = versionParts(tokens2[1]);
+    return a && b && a.major <= b.major ? { lower: a.major, upper: b.major } : void 0;
+  }
+  const tokens = r.replace(/(>=|<=|>|<|=)\s+/g, "$1").split(/\s+/);
+  const lowers = [];
+  const uppers = [];
+  for (const t of tokens) {
+    const c = /^(>=|<=|>|<|=)(.+)$/.exec(t);
+    if (!c) return void 0;
+    const v = versionParts(c[2]);
+    if (v === void 0) return void 0;
+    const b = comparatorBounds(c[1], v);
+    if (b.lower !== void 0) lowers.push(b.lower);
+    if (b.upper !== void 0) uppers.push(b.upper);
+  }
+  if (lowers.length === 0) return void 0;
+  const lower = Math.max(...lowers);
+  const upper = uppers.length > 0 ? Math.min(...uppers) : void 0;
+  if (upper !== void 0 && upper < lower) return void 0;
+  return upper !== void 0 ? { lower, upper } : { lower };
+}
+function majorWithin(major, bounds) {
+  return major >= bounds.lower && (bounds.upper === void 0 || major <= bounds.upper);
+}
+function majorFromVersion(version) {
+  if (typeof version !== "string") return void 0;
+  const v = version.trim();
+  const m = /^v?(\d+)\.\d+\.\d+(?:[-+][0-9A-Za-z.+-]*)?$/.exec(v);
+  if (!m || /^v?0\.0\.0-/.test(v)) return void 0;
+  return Number(m[1]);
+}
+function detectTailwind(baseDirInput, pkg) {
+  const baseDir = resolve3(baseDirInput);
+  const installedFile = join5(baseDir, "node_modules", "tailwindcss", "package.json");
+  const declared = pkg ? hasDependency(pkg, "tailwindcss") : void 0;
+  const bounds = declared !== void 0 ? tailwindMajorBounds(declared) : void 0;
+  const declaredMajor = bounds?.lower;
+  try {
+    const installed = JSON.parse(readFileSync6(installedFile, "utf8"));
+    const version = isPlainObject(installed) ? installed.version : void 0;
+    const major = majorFromVersion(version);
+    if (major !== void 0) {
+      const found = { major, source: "installed", value: String(version) };
+      if (declared !== void 0 && bounds !== void 0 && !majorWithin(major, bounds)) {
+        found.mismatch = { declared, declaredMajor: bounds.lower };
+      }
+      return found;
+    }
+  } catch {
+  }
+  if (declared !== void 0) {
+    if (declaredMajor !== void 0) return { major: declaredMajor, source: "declared", value: declared };
+    return { source: "none", value: declared };
+  }
+  return { source: "none" };
+}
+var TAILWIND_CONFIG_FILES = [
+  "tailwind.config.ts",
+  "tailwind.config.js",
+  "tailwind.config.mjs",
+  "tailwind.config.cjs"
+];
+var TAILWIND_CSS_CANDIDATES = [
+  "globals.css",
+  "app/globals.css",
+  "src/app/globals.css",
+  "src/globals.css",
+  "styles/globals.css"
+];
+var TAILWIND_IMPORT = /@import\s+(?:url\(\s*)?["']tailwindcss["']/;
+function hasTailwindImport(css) {
+  return TAILWIND_IMPORT.test(css.replace(/\/\*[\s\S]*?\*\//g, ""));
+}
+function readPackageJson(baseDir) {
+  try {
+    const parsed = JSON.parse(readFileSync6(join5(baseDir, "package.json"), "utf8"));
+    return isPlainObject(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function checkTailwindSetup(baseDirInput) {
+  const baseDir = resolve3(baseDirInput);
+  const tailwind = detectTailwind(baseDir, readPackageJson(baseDir));
+  if (tailwind.major !== void 0 && tailwind.major >= 4) {
+    const label = `Tailwind ${tailwind.major}`;
+    for (const candidate of TAILWIND_CSS_CANDIDATES) {
+      const file = join5(baseDir, candidate);
+      if (!existsSync5(file)) continue;
+      const found = hasTailwindImport(readFileSync6(file, "utf8"));
+      return {
+        name: "tailwind.config",
+        severity: found ? "pass" : "warn",
+        message: found ? `${label}: ${candidate}\uC5D0 @import "tailwindcss" \uAC00 \uC788\uC2B5\uB2C8\uB2E4` : `${label}: ${candidate}\uC5D0 @import "tailwindcss" \uAC00 \uC5C6\uC2B5\uB2C8\uB2E4`
+      };
+    }
+    return {
+      name: "tailwind.config",
+      severity: "warn",
+      message: `${label}: @import "tailwindcss" \uB97C \uD655\uC778\uD560 CSS \uD30C\uC77C\uC744 \uCC3E\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4`
+    };
+  }
+  const [tsFile, ...otherFiles] = TAILWIND_CONFIG_FILES;
+  const tsPath = join5(baseDir, tsFile);
+  if (existsSync5(tsPath)) {
+    const content = readFileSync6(tsPath, "utf8");
+    const hasTokens = content.includes("--background") || content.includes("hsl(var(");
+    return {
+      name: "tailwind.config",
+      severity: hasTokens ? "pass" : "warn",
+      message: hasTokens ? "tailwind.config.ts\uC5D0 AXIS \uD1A0\uD070\uC774 \uC124\uC815\uB418\uC5B4 \uC788\uC2B5\uB2C8\uB2E4" : "tailwind.config.ts\uC5D0 AXIS \uD1A0\uD070 \uC124\uC815\uC774 \uC5C6\uC2B5\uB2C8\uB2E4"
+    };
+  }
+  for (const file of otherFiles) {
+    if (existsSync5(join5(baseDir, file))) {
+      return { name: "tailwind.config", severity: "warn", message: `${file} \uC874\uC7AC (TypeScript \uAD8C\uC7A5)` };
+    }
+  }
+  return { name: "tailwind.config", severity: "fail", message: "tailwind.config \uD30C\uC77C\uC774 \uC5C6\uC2B5\uB2C8\uB2E4" };
+}
+
+// src/tools/template.ts
 var TEMPLATE_REGISTRY_URL = process.env.AXIS_TEMPLATE_URL || "https://axis.minu.best/templates";
 async function fetchTemplateIndex() {
   const url = `${TEMPLATE_REGISTRY_URL}/index.json`;
@@ -2188,6 +2606,36 @@ async function handleDiffTemplate(params) {
   };
   return { templateName: detail.name, entries, summary };
 }
+function brandCheckResult(check) {
+  const { brand } = check;
+  const suffix = check.configuredMissing !== void 0 ? ` (globalCss ${check.configuredMissing} \uC5C6\uC74C)` : "";
+  switch (check.state) {
+    case "match":
+      return {
+        name: "brand",
+        severity: "pass",
+        message: `brand "${brand}" import \uAC00 ${check.cssFile}\uC5D0 \uC788\uC2B5\uB2C8\uB2E4${suffix}`
+      };
+    case "css-missing":
+      return {
+        name: "brand",
+        severity: "warn",
+        message: `brand "${brand}" \uAC00 \uC124\uC815\uB410\uC9C0\uB9CC CSS \uD30C\uC77C\uC744 \uCC3E\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4${suffix}`
+      };
+    case "import-missing":
+      return {
+        name: "brand",
+        severity: "warn",
+        message: `brand "${brand}" import \uAC00 ${check.cssFile}\uC5D0 \uC5C6\uC2B5\uB2C8\uB2E4 \u2192 'axis theme add ${brand}'${suffix}`
+      };
+    case "other-brand":
+      return {
+        name: "brand",
+        severity: "warn",
+        message: `brand "${brand}" \uC640 import(${check.imports.join(", ")})\uAC00 \uB2E4\uB985\uB2C8\uB2E4${suffix}`
+      };
+  }
+}
 async function handleCheckProject(params) {
   const baseDir = path3.resolve(params.targetDir || ".");
   const results = [];
@@ -2197,29 +2645,7 @@ async function handleCheckProject(params) {
     severity: configExists ? "pass" : "fail",
     message: configExists ? "axis.config.json \uD30C\uC77C\uC774 \uC874\uC7AC\uD569\uB2C8\uB2E4" : "axis.config.json \uD30C\uC77C\uC774 \uC5C6\uC2B5\uB2C8\uB2E4 \u2192 'axis init'\uC744 \uC2E4\uD589\uD558\uC138\uC694"
   });
-  const twTs = path3.join(baseDir, "tailwind.config.ts");
-  const twJs = path3.join(baseDir, "tailwind.config.js");
-  if (await fs3.pathExists(twTs)) {
-    const content = await fs3.readFile(twTs, "utf-8");
-    const hasTokens = content.includes("--background") || content.includes("hsl(var(");
-    results.push({
-      name: "tailwind.config",
-      severity: hasTokens ? "pass" : "warn",
-      message: hasTokens ? "tailwind.config.ts\uC5D0 AXIS \uD1A0\uD070\uC774 \uC124\uC815\uB418\uC5B4 \uC788\uC2B5\uB2C8\uB2E4" : "tailwind.config.ts\uC5D0 AXIS \uD1A0\uD070 \uC124\uC815\uC774 \uC5C6\uC2B5\uB2C8\uB2E4"
-    });
-  } else if (await fs3.pathExists(twJs)) {
-    results.push({
-      name: "tailwind.config",
-      severity: "warn",
-      message: "tailwind.config.js \uC874\uC7AC (TypeScript \uAD8C\uC7A5)"
-    });
-  } else {
-    results.push({
-      name: "tailwind.config",
-      severity: "fail",
-      message: "tailwind.config \uD30C\uC77C\uC774 \uC5C6\uC2B5\uB2C8\uB2E4"
-    });
-  }
+  results.push(checkTailwindSetup(baseDir));
   const cssCandidates = [
     "globals.css",
     "app/globals.css",
@@ -2312,6 +2738,8 @@ async function handleCheckProject(params) {
       message: "package.json \uD30C\uC77C\uC774 \uC5C6\uC2B5\uB2C8\uB2E4"
     });
   }
+  const brandCheck = inspectBrandImport(baseDir);
+  if (brandCheck) results.push(brandCheckResult(brandCheck));
   const summary = {
     pass: results.filter((r) => r.severity === "pass").length,
     warn: results.filter((r) => r.severity === "warn").length,
@@ -2426,10 +2854,137 @@ function formatCheckProjectResult(result) {
   return lines.join("\n");
 }
 
+// src/tools/brand.ts
+import path4 from "path";
+var TOKENS_INSTALL_COMMAND = `pnpm add ${TOKENS_PACKAGE}@^${MIN_BRAND_TOKENS_VERSION}`;
+function baseDirOf(targetDir) {
+  return path4.resolve(targetDir || process.cwd());
+}
+async function handleListBrands(params) {
+  return listBrands(baseDirOf(params.targetDir));
+}
+async function handleGetBrand(params) {
+  const { name } = params;
+  if (!name || name.trim() === "") {
+    throw new Error("\uBE0C\uB79C\uB4DC \uC774\uB984(name)\uC740 \uD544\uC218\uC785\uB2C8\uB2E4.");
+  }
+  return getBrand(baseDirOf(params.targetDir), name);
+}
+function formatTokensStatusGuide(status, version) {
+  switch (status) {
+    case "not-installed":
+      return [
+        `${TOKENS_PACKAGE} \uAC00 \uC124\uCE58\uB3FC \uC788\uC9C0 \uC54A\uC544 \uBE0C\uB79C\uB4DC\uB97C \uC77D\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.`,
+        "",
+        `- \uC124\uCE58: \`${TOKENS_INSTALL_COMMAND}\``
+      ].join("\n");
+    case "unsupported":
+      return [
+        `${TOKENS_PACKAGE} ${version ?? "(\uBC84\uC804 \uBAA8\uB984)"} \uC740 \uBE0C\uB79C\uB4DC\uB97C \uC9C0\uC6D0\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4(${MIN_BRAND_TOKENS_VERSION} \uC774\uC0C1 \uD544\uC694).`,
+        "",
+        `- \uC5C5\uADF8\uB808\uC774\uB4DC: \`${TOKENS_INSTALL_COMMAND}\``
+      ].join("\n");
+    case "not-built":
+      return [
+        `${TOKENS_PACKAGE}${version ? ` ${version}` : ""} \uB294 \uC788\uC9C0\uB9CC \uBE4C\uB4DC \uC0B0\uCD9C\uBB3C\uC774 \uC5C6\uC5B4 \uBE0C\uB79C\uB4DC\uB97C \uC77D\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.`,
+        "",
+        `- \uC6CC\uD06C\uC2A4\uD398\uC774\uC2A4\uBA74 \`pnpm --filter ${TOKENS_PACKAGE} build\`, \uC544\uB2C8\uBA74 \uC7AC\uC124\uCE58: \`${TOKENS_INSTALL_COMMAND}\``
+      ].join("\n");
+  }
+}
+function formatListBrandsResult(result) {
+  const lines = ["## AXIS \uBE0C\uB79C\uB4DC\n"];
+  if (result.status !== "ok") {
+    lines.push(formatTokensStatusGuide(result.status, result.version));
+    return lines.join("\n");
+  }
+  if (result.brands.length === 0) {
+    lines.push(`\uC124\uCE58\uB41C ${TOKENS_PACKAGE} ${result.version ?? ""} \uC5D0 \uBE0C\uB79C\uB4DC\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4.`);
+    return lines.join("\n");
+  }
+  lines.push(`${TOKENS_PACKAGE} ${result.version ?? ""} \uC5D0 \uBE0C\uB79C\uB4DC ${result.brands.length}\uAC1C\uAC00 \uC788\uC2B5\uB2C8\uB2E4.`, "");
+  for (const b of result.brands) {
+    lines.push(`- **${b.name}**: ${b.description} (${b.themes.join(" \xB7 ")})`);
+    lines.push(`  - import: \`${b.importPath}\``);
+  }
+  lines.push("", "\uC0C1\uC138: `axis.get_brand` (name)");
+  return lines.join("\n");
+}
+function a11yValue(value) {
+  return value === null || value === void 0 || value === "" ? "-" : String(value);
+}
+function tokenTable(brand) {
+  const rows = KEY_TOKENS.filter((k) => k in brand.tokens.light || k in brand.tokens.dark);
+  const missing = KEY_TOKENS.filter((k) => !(k in brand.tokens.light) && !(k in brand.tokens.dark));
+  const lines = [];
+  if (rows.length > 0) {
+    lines.push("| \uD1A0\uD070 | \uB77C\uC774\uD2B8 | \uB2E4\uD06C |", "|---|---|---|");
+    for (const k of rows) {
+      lines.push(`| \`${k}\` | ${brand.tokens.light[k] ?? "-"} | ${brand.tokens.dark[k] ?? "-"} |`);
+    }
+  }
+  if (missing.length > 0) {
+    if (lines.length > 0) lines.push("");
+    lines.push(`\uBE0C\uB79C\uB4DC\uAC00 \uB36E\uC5B4\uC4F0\uC9C0 \uC54A\uC74C: ${missing.join(", ")}`);
+  }
+  return lines;
+}
+function formatGetBrandResult(result, name) {
+  if (result.status !== "ok") {
+    return [`## \uBE0C\uB79C\uB4DC: ${name}
+`, formatTokensStatusGuide(result.status, result.version)].join("\n");
+  }
+  const brand = result.brand;
+  if (!brand) {
+    return [
+      `## \uBE0C\uB79C\uB4DC: ${name}
+`,
+      `\uBE0C\uB79C\uB4DC '${name}' \uAC00 \uC124\uCE58\uB41C ${TOKENS_PACKAGE} ${result.version ?? ""} \uC5D0 \uC5C6\uC2B5\uB2C8\uB2E4.`,
+      "",
+      `- \uC124\uCE58\uB41C \uBE0C\uB79C\uB4DC: ${result.available.length > 0 ? result.available.join(", ") : "(\uC5C6\uC74C)"}`,
+      "- \uBAA9\uB85D: `axis.list_brands`"
+    ].join("\n");
+  }
+  return [
+    `## \uBE0C\uB79C\uB4DC: ${brand.name}
+`,
+    `- \uC124\uBA85: ${brand.description}`,
+    `- \uD14C\uB9C8: ${brand.themes.join(" \xB7 ")}`,
+    "",
+    "### Import (globals.css, @charset \xB7 \uB2E4\uB978 @import \uB2E4\uC74C)",
+    "",
+    "```css",
+    `@import "${brand.importPath}";`,
+    "```",
+    "",
+    "### Provider (@axis-ds/theme 1.3.0 \uC774\uC0C1)",
+    "",
+    "```tsx",
+    brand.providerExample,
+    "```",
+    "",
+    `ThemeProvider \uB098 <html data-brand="${brand.name}"> \uAC00 \uC5C6\uC73C\uBA74 import \uB9CC\uC73C\uB85C\uB294 \uD654\uBA74\uC774 \uBC14\uB00C\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.`,
+    "",
+    "### \uC8FC\uC694 \uD1A0\uD070",
+    "",
+    ...tokenTable(brand),
+    "",
+    "### \uBCF4\uC815 \uB0B4\uC5ED",
+    "",
+    `- a11y \uC0C1\uD0DC: ${a11yValue(brand.adjustments.a11y.status)}`,
+    `- \uC810\uAC80\uC77C: ${a11yValue(brand.adjustments.a11y.checkedAt)}`,
+    `- \uAC8C\uC774\uD2B8: ${a11yValue(brand.adjustments.a11y.gate)}`,
+    `- \uADFC\uAC70 \uBB38\uC11C: ${brand.adjustments.reference}`,
+    "",
+    "\uBCF4\uC815 \uC804 \xB7 \uD6C4 \uAC12\uC740 \uC774 \uBC84\uC804\uC5D0\uC11C \uCD9C\uB825\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4."
+  ].join("\n");
+}
+
 // src/index.ts
+var { version: SERVER_VERSION } = createRequire2(import.meta.url)("../package.json");
 var server = new McpServer({
   name: "axis-design-system",
-  version: "0.1.0"
+  version: SERVER_VERSION
 });
 var ComponentCategorySchema = z.enum(["core", "agentic", "form", "layout"]).optional().describe("\uCEF4\uD3EC\uB10C\uD2B8 \uCE74\uD14C\uACE0\uB9AC \uD544\uD130");
 var TokenCategorySchema = z.enum(["color", "typography", "spacing", "radius", "shadow", "animation"]).optional().describe("\uD1A0\uD070 \uCE74\uD14C\uACE0\uB9AC \uD544\uD130");
@@ -2575,9 +3130,9 @@ server.tool(
   {
     path: z.string().describe("\uD1A0\uD070 \uACBD\uB85C (\uC608: colors.primary, spacing.4)")
   },
-  async ({ path: path4 }) => {
+  async ({ path: path5 }) => {
     try {
-      const token = handleGetToken({ path: path4 });
+      const token = handleGetToken({ path: path5 });
       const formatted = formatTokenDetail(token);
       return {
         content: [
@@ -2978,6 +3533,71 @@ server.tool(
     }
   }
 );
+server.tool(
+  "axis.list_brands",
+  "\uB300\uC0C1 \uD504\uB85C\uC81D\uD2B8\uC5D0 \uC124\uCE58\uB41C @axis-ds/tokens \uC758 \uBE0C\uB79C\uB4DC \uBAA9\uB85D(\uC774\uB984 \xB7 \uC124\uBA85 \xB7 \uD14C\uB9C8 \xB7 import \uACBD\uB85C)\uC744 \uC870\uD68C\uD569\uB2C8\uB2E4.",
+  {
+    targetDir: z.string().optional().describe("\uB300\uC0C1 \uD504\uB85C\uC81D\uD2B8 \uB514\uB809\uD1A0\uB9AC (\uAE30\uBCF8: \uD604\uC7AC \uB514\uB809\uD1A0\uB9AC)")
+  },
+  async ({ targetDir }) => {
+    try {
+      const result = await handleListBrands({ targetDir });
+      const formatted = formatListBrandsResult(result);
+      return {
+        content: [
+          {
+            type: "text",
+            text: formatted
+          }
+        ]
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "\uC54C \uC218 \uC5C6\uB294 \uC624\uB958";
+      return {
+        content: [
+          {
+            type: "text",
+            text: `\uC624\uB958: ${message}`
+          }
+        ],
+        isError: true
+      };
+    }
+  }
+);
+server.tool(
+  "axis.get_brand",
+  "\uBE0C\uB79C\uB4DC \uD558\uB098\uC758 import \uACBD\uB85C \xB7 Provider \uC124\uC815 \uC608\uC2DC(defaultBrand) \xB7 \uC8FC\uC694 \uD1A0\uD070 \xB7 \uBCF4\uC815 \uB0B4\uC5ED\uC744 \uC870\uD68C\uD569\uB2C8\uB2E4.",
+  {
+    name: z.string().describe("\uBE0C\uB79C\uB4DC \uC774\uB984 (\uC608: ontology)"),
+    targetDir: z.string().optional().describe("\uB300\uC0C1 \uD504\uB85C\uC81D\uD2B8 \uB514\uB809\uD1A0\uB9AC (\uAE30\uBCF8: \uD604\uC7AC \uB514\uB809\uD1A0\uB9AC)")
+  },
+  async ({ name, targetDir }) => {
+    try {
+      const result = await handleGetBrand({ name, targetDir });
+      const formatted = formatGetBrandResult(result, name);
+      return {
+        content: [
+          {
+            type: "text",
+            text: formatted
+          }
+        ]
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "\uC54C \uC218 \uC5C6\uB294 \uC624\uB958";
+      return {
+        content: [
+          {
+            type: "text",
+            text: `\uC624\uB958: ${message}`
+          }
+        ],
+        isError: true
+      };
+    }
+  }
+);
 async function main() {
   const transport = new StdioServerTransport();
   await server.connect(transport);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axis-ds/mcp",
-  "version": "1.1.5",
+  "version": "1.2.1",
   "type": "module",
   "description": "AXIS Design System - MCP Server for AI-assisted component discovery",
   "bin": {
@@ -25,7 +25,8 @@
     "@types/fs-extra": "^11.0.0",
     "@types/node": "^22.0.0",
     "tsup": "^8.0.0",
-    "typescript": "^5.7.0"
+    "typescript": "^5.7.0",
+    "vitest": "^2.1.0"
   },
   "keywords": [
     "mcp",
@@ -45,6 +46,7 @@
     "build": "tsup src/index.ts --format esm --dts --clean && npm run copy-data",
     "copy-data": "node -e \"const fs=require('fs');fs.cpSync('src/registry/data','dist/data',{recursive:true})\"",
     "dev": "tsup src/index.ts --format esm --watch",
-    "clean": "rm -rf dist"
+    "clean": "rm -rf dist",
+    "test": "vitest run"
   }
 }