@axis-ds/cli 1.1.0

package/dist/index.js

@@ -0,0 +1,2501 @@
+#!/usr/bin/env node
+import {
+  MonetClient
+} from "./chunk-WRDOGNSG.js";
+import {
+  V0Client
+} from "./chunk-GCOWKKXG.js";
+import {
+  registerSyncCommand
+} from "./chunk-D26GW2HO.js";
+import {
+  fetchTemplateDetail,
+  fetchTemplateIndex
+} from "./chunk-CGFESSCW.js";
+
+// src/index.ts
+import { Command } from "commander";
+import chalk8 from "chalk";
+import ora6 from "ora";
+import fs9 from "fs-extra";
+import path9 from "path";
+import prompts2 from "prompts";
+
+// src/library/base-collector.ts
+import crypto from "crypto";
+var CATEGORY_RULES = [
+  {
+    category: "agentic",
+    patterns: [
+      /streaming/i,
+      /agent/i,
+      /approval/i,
+      /step[-_]?indicator/i,
+      /tool[-_]?call/i,
+      /run[-_]?container/i,
+      /surface/i,
+      /thinking/i
+    ]
+  },
+  {
+    category: "form",
+    patterns: [
+      /input/i,
+      /select/i,
+      /checkbox/i,
+      /radio/i,
+      /switch/i,
+      /form/i,
+      /textarea/i,
+      /slider/i,
+      /date[-_]?picker/i,
+      /label/i
+    ]
+  },
+  {
+    category: "layout",
+    patterns: [
+      /container/i,
+      /grid/i,
+      /flex/i,
+      /stack/i,
+      /spacer/i,
+      /divider/i,
+      /separator/i,
+      /aspect[-_]?ratio/i
+    ]
+  },
+  {
+    category: "navigation",
+    patterns: [
+      /nav/i,
+      /menu/i,
+      /breadcrumb/i,
+      /tabs/i,
+      /pagination/i,
+      /sidebar/i,
+      /header/i,
+      /footer/i
+    ]
+  },
+  {
+    category: "feedback",
+    patterns: [
+      /toast/i,
+      /alert/i,
+      /notification/i,
+      /progress/i,
+      /spinner/i,
+      /skeleton/i,
+      /loading/i
+    ]
+  },
+  {
+    category: "overlay",
+    patterns: [
+      /modal/i,
+      /dialog/i,
+      /drawer/i,
+      /popover/i,
+      /tooltip/i,
+      /dropdown/i,
+      /sheet/i
+    ]
+  },
+  {
+    category: "data-display",
+    patterns: [
+      /table/i,
+      /list/i,
+      /card/i,
+      /avatar/i,
+      /badge/i,
+      /tag/i,
+      /timeline/i,
+      /tree/i
+    ]
+  },
+  {
+    category: "chart",
+    patterns: [
+      /chart/i,
+      /graph/i,
+      /pie/i,
+      /bar/i,
+      /line/i,
+      /area/i,
+      /scatter/i,
+      /radar/i
+    ]
+  }
+];
+var TAG_PATTERNS = [
+  { pattern: /useState|useReducer/, tag: "stateful" },
+  { pattern: /useEffect|useLayoutEffect/, tag: "side-effects" },
+  { pattern: /forwardRef/, tag: "forwardRef" },
+  { pattern: /motion|animate|transition/, tag: "animated" },
+  { pattern: /accessible|aria-/, tag: "accessible" },
+  { pattern: /responsive|breakpoint|media/, tag: "responsive" }
+];
+var BaseCollector = class {
+  /**
+   * 전체 컴포넌트 수집
+   */
+  async collectAll(options) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const items = [];
+    const errors = [];
+    try {
+      let componentList = await this.listComponents();
+      if (options?.filter?.categories) {
+        componentList = componentList.filter(
+          (c) => c.category && options.filter.categories.includes(c.category)
+        );
+      }
+      for (const item of componentList) {
+        try {
+          const component = await this.collectComponent(item.id);
+          items.push({
+            id: component.id,
+            name: component.name,
+            status: "new",
+            // 증분 수집 시 로직 추가 필요
+            checksum: component.checksum
+          });
+        } catch (error) {
+          errors.push({
+            id: item.id,
+            error: error instanceof Error ? error.message : "Unknown error",
+            recoverable: true
+          });
+        }
+      }
+      return {
+        source: this.sourceType,
+        timestamp,
+        success: errors.length === 0,
+        collected: items.length,
+        updated: 0,
+        failed: errors.length,
+        items,
+        errors
+      };
+    } catch (error) {
+      return {
+        source: this.sourceType,
+        timestamp,
+        success: false,
+        collected: 0,
+        updated: 0,
+        failed: 1,
+        items: [],
+        errors: [
+          {
+            id: "root",
+            error: error instanceof Error ? error.message : "Unknown error",
+            recoverable: false
+          }
+        ]
+      };
+    }
+  }
+  /**
+   * 변경 감지
+   */
+  async detectChanges(lastChecksum) {
+    const currentList = await this.listComponents();
+    const currentIds = new Set(currentList.map((c) => c.id));
+    const previousIds = new Set(Object.keys(lastChecksum));
+    const added = currentList.filter((c) => !previousIds.has(c.id)).map((c) => c.id);
+    const removed = [...previousIds].filter((id) => !currentIds.has(id));
+    const modified = [];
+    for (const item of currentList) {
+      if (previousIds.has(item.id)) {
+        try {
+          const component = await this.collectComponent(item.id);
+          if (component.checksum !== lastChecksum[item.id]) {
+            modified.push(item.id);
+          }
+        } catch {
+          modified.push(item.id);
+        }
+      }
+    }
+    return { added, modified, removed };
+  }
+  // ============================================================================
+  // Protected Helpers
+  // ============================================================================
+  /**
+   * 카테고리 자동 분류
+   */
+  classifyCategory(name, code) {
+    const searchText = `${name} ${code || ""}`.toLowerCase();
+    for (const rule of CATEGORY_RULES) {
+      for (const pattern of rule.patterns) {
+        if (pattern.test(searchText)) {
+          return rule.category;
+        }
+      }
+    }
+    return "ui";
+  }
+  /**
+   * 태그 자동 추출
+   */
+  extractTags(name, code) {
+    const tags = [];
+    const searchText = code || "";
+    for (const { pattern, tag } of TAG_PATTERNS) {
+      if (pattern.test(searchText)) {
+        tags.push(tag);
+      }
+    }
+    const nameLower = name.toLowerCase();
+    if (nameLower.includes("button")) tags.push("interactive");
+    if (nameLower.includes("card")) tags.push("container");
+    if (nameLower.includes("input") || nameLower.includes("form")) tags.push("input");
+    return [...new Set(tags)];
+  }
+  /**
+   * 체크섬 계산
+   */
+  calculateChecksum(content) {
+    return crypto.createHash("md5").update(content).digest("hex").slice(0, 8);
+  }
+  /**
+   * 슬러그 생성
+   */
+  generateSlug(name) {
+    return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+  }
+  /**
+   * ID 생성
+   */
+  generateId(name) {
+    return `${this.sourceType}-${this.generateSlug(name)}`;
+  }
+  /**
+   * 의존성 추출
+   */
+  extractDependencies(code) {
+    const dependencies = [];
+    const devDependencies = [];
+    const registryDeps = [];
+    const importRegex = /from\s+['"]([^'"]+)['"]/g;
+    let match;
+    while ((match = importRegex.exec(code)) !== null) {
+      const pkg = match[1];
+      if (pkg.startsWith(".") || pkg.startsWith("@/")) {
+        continue;
+      }
+      if (pkg.startsWith("@axis") || pkg.includes("/ui/")) {
+        registryDeps.push(pkg);
+        continue;
+      }
+      const pkgName = pkg.startsWith("@") ? pkg.split("/").slice(0, 2).join("/") : pkg.split("/")[0];
+      if (pkgName === "react" || pkgName === "react-dom") {
+        continue;
+      }
+      if (!dependencies.includes(pkgName)) {
+        dependencies.push(pkgName);
+      }
+    }
+    return { dependencies, devDependencies, registryDeps };
+  }
+  /**
+   * ComponentMeta 기본 구조 생성
+   */
+  createBaseMeta(name, description, files, options = {}) {
+    const code = files.map((f) => f.content).join("\n");
+    const deps = this.extractDependencies(code);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    return {
+      id: this.generateId(name),
+      slug: this.generateSlug(name),
+      name,
+      description,
+      source: {
+        type: this.sourceType,
+        registry: options.registry || `@${this.sourceType}`,
+        url: options.url || "",
+        version: options.version
+      },
+      category: this.classifyCategory(name, code),
+      tags: this.extractTags(name, code),
+      code: {
+        files,
+        dependencies: deps.dependencies,
+        devDependencies: deps.devDependencies,
+        registryDeps: deps.registryDeps
+      },
+      status: "active",
+      collectedAt: now,
+      updatedAt: now,
+      checksum: this.calculateChecksum(code)
+    };
+  }
+};
+
+// src/library/shadcn-collector.ts
+var ShadcnCollector = class extends BaseCollector {
+  sourceType = "shadcn";
+  baseUrl = "https://ui.shadcn.com";
+  registryUrl = "https://ui.shadcn.com/r";
+  constructor(options = {}) {
+    super();
+    if (options.baseUrl) {
+      this.baseUrl = options.baseUrl;
+      this.registryUrl = `${options.baseUrl}/r`;
+    }
+  }
+  /**
+   * 컴포넌트 목록 조회
+   */
+  async listComponents() {
+    try {
+      const response = await fetch(`${this.registryUrl}/index.json`);
+      if (!response.ok) {
+        return this.getDefaultComponentList();
+      }
+      const data = await response.json();
+      return data.items.map((item) => ({
+        id: `shadcn-${item.name}`,
+        name: item.name,
+        description: item.description || `shadcn/ui ${item.name} component`,
+        category: this.classifyCategory(item.name),
+        source: "shadcn"
+      }));
+    } catch (error) {
+      console.warn("shadcn \uB808\uC9C0\uC2A4\uD2B8\uB9AC \uC778\uB371\uC2A4 \uC870\uD68C \uC2E4\uD328, \uAE30\uBCF8 \uBAA9\uB85D \uC0AC\uC6A9:", error);
+      return this.getDefaultComponentList();
+    }
+  }
+  /**
+   * 단일 컴포넌트 수집
+   */
+  async collectComponent(id) {
+    const name = id.replace("shadcn-", "");
+    try {
+      const response = await fetch(`${this.registryUrl}/${name}.json`);
+      if (!response.ok) {
+        throw new Error(`Component not found: ${name}`);
+      }
+      const data = await response.json();
+      const files = data.files.map((f) => ({
+        path: f.target || f.path,
+        content: f.content,
+        type: this.getFileType(f.path)
+      }));
+      const meta = this.createBaseMeta(
+        data.name,
+        data.description || `shadcn/ui ${data.name} component`,
+        files,
+        {
+          registry: "@shadcn",
+          url: `${this.baseUrl}/docs/components/${name}`
+        }
+      );
+      if (data.dependencies) {
+        meta.code.dependencies = [
+          .../* @__PURE__ */ new Set([...meta.code.dependencies, ...data.dependencies])
+        ];
+      }
+      if (data.devDependencies) {
+        meta.code.devDependencies = [
+          .../* @__PURE__ */ new Set([...meta.code.devDependencies, ...data.devDependencies])
+        ];
+      }
+      if (data.registryDependencies) {
+        meta.code.registryDeps = [
+          .../* @__PURE__ */ new Set([...meta.code.registryDeps, ...data.registryDependencies])
+        ];
+      }
+      return meta;
+    } catch (error) {
+      return this.createBaseMeta(name, `shadcn/ui ${name} component`, [], {
+        registry: "@shadcn",
+        url: `${this.baseUrl}/docs/components/${name}`
+      });
+    }
+  }
+  /**
+   * 기본 컴포넌트 목록 (레지스트리 인덱스 없을 때)
+   */
+  getDefaultComponentList() {
+    const components = [
+      { name: "accordion", desc: "Accordion component" },
+      { name: "alert", desc: "Alert component" },
+      { name: "alert-dialog", desc: "Alert dialog component" },
+      { name: "aspect-ratio", desc: "Aspect ratio component" },
+      { name: "avatar", desc: "Avatar component" },
+      { name: "badge", desc: "Badge component" },
+      { name: "breadcrumb", desc: "Breadcrumb component" },
+      { name: "button", desc: "Button component" },
+      { name: "calendar", desc: "Calendar component" },
+      { name: "card", desc: "Card component" },
+      { name: "carousel", desc: "Carousel component" },
+      { name: "chart", desc: "Chart component" },
+      { name: "checkbox", desc: "Checkbox component" },
+      { name: "collapsible", desc: "Collapsible component" },
+      { name: "command", desc: "Command component" },
+      { name: "context-menu", desc: "Context menu component" },
+      { name: "dialog", desc: "Dialog component" },
+      { name: "drawer", desc: "Drawer component" },
+      { name: "dropdown-menu", desc: "Dropdown menu component" },
+      { name: "form", desc: "Form component" },
+      { name: "hover-card", desc: "Hover card component" },
+      { name: "input", desc: "Input component" },
+      { name: "input-otp", desc: "Input OTP component" },
+      { name: "label", desc: "Label component" },
+      { name: "menubar", desc: "Menubar component" },
+      { name: "navigation-menu", desc: "Navigation menu component" },
+      { name: "pagination", desc: "Pagination component" },
+      { name: "popover", desc: "Popover component" },
+      { name: "progress", desc: "Progress component" },
+      { name: "radio-group", desc: "Radio group component" },
+      { name: "resizable", desc: "Resizable component" },
+      { name: "scroll-area", desc: "Scroll area component" },
+      { name: "select", desc: "Select component" },
+      { name: "separator", desc: "Separator component" },
+      { name: "sheet", desc: "Sheet component" },
+      { name: "sidebar", desc: "Sidebar component" },
+      { name: "skeleton", desc: "Skeleton component" },
+      { name: "slider", desc: "Slider component" },
+      { name: "sonner", desc: "Sonner toast component" },
+      { name: "switch", desc: "Switch component" },
+      { name: "table", desc: "Table component" },
+      { name: "tabs", desc: "Tabs component" },
+      { name: "textarea", desc: "Textarea component" },
+      { name: "toast", desc: "Toast component" },
+      { name: "toggle", desc: "Toggle component" },
+      { name: "toggle-group", desc: "Toggle group component" },
+      { name: "tooltip", desc: "Tooltip component" }
+    ];
+    return components.map((c) => ({
+      id: `shadcn-${c.name}`,
+      name: c.name,
+      description: c.desc,
+      category: this.classifyCategory(c.name),
+      source: "shadcn"
+    }));
+  }
+  /**
+   * 파일 타입 추론
+   */
+  getFileType(path10) {
+    if (path10.includes("hook") || path10.startsWith("use")) return "hook";
+    if (path10.includes("util") || path10.includes("lib")) return "util";
+    if (path10.endsWith(".css")) return "style";
+    if (path10.endsWith(".d.ts") || path10.includes("types")) return "type";
+    return "component";
+  }
+};
+
+// src/library/monet-collector.ts
+var MONET_CATEGORIES = [
+  { id: "hero", name: "Hero Sections", count: 120, desc: "\uD788\uC5B4\uB85C \uC139\uC158 \uCEF4\uD3EC\uB10C\uD2B8" },
+  { id: "feature", name: "Feature Sections", count: 191, desc: "\uAE30\uB2A5 \uC18C\uAC1C \uC139\uC158" },
+  { id: "testimonial", name: "Testimonials", count: 47, desc: "\uACE0\uAC1D \uD6C4\uAE30 \uC139\uC158" },
+  { id: "pricing", name: "Pricing Tables", count: 35, desc: "\uC694\uAE08\uC81C \uD14C\uC774\uBE14" },
+  { id: "cta", name: "Call to Action", count: 42, desc: "CTA \uC139\uC158" },
+  { id: "stats", name: "Statistics", count: 28, desc: "\uD1B5\uACC4 \uC139\uC158" },
+  { id: "footer", name: "Footers", count: 38, desc: "\uD478\uD130 \uCEF4\uD3EC\uB10C\uD2B8" },
+  { id: "header", name: "Headers/Navigation", count: 45, desc: "\uD5E4\uB354/\uB124\uBE44\uAC8C\uC774\uC158" },
+  { id: "logo-cloud", name: "Logo Clouds", count: 22, desc: "\uB85C\uACE0 \uD074\uB77C\uC6B0\uB4DC" },
+  { id: "team", name: "Team Sections", count: 31, desc: "\uD300 \uC18C\uAC1C \uC139\uC158" },
+  { id: "faq", name: "FAQ Sections", count: 24, desc: "FAQ \uC139\uC158" },
+  { id: "contact", name: "Contact Forms", count: 29, desc: "\uBB38\uC758 \uD3FC" },
+  { id: "newsletter", name: "Newsletter", count: 18, desc: "\uB274\uC2A4\uB808\uD130 \uC139\uC158" },
+  { id: "landing", name: "Full Landing Pages", count: 28, desc: "\uB79C\uB529 \uD398\uC774\uC9C0" }
+];
+var MONET_EXAMPLES = {
+  hero: [
+    { id: "hero-with-image", name: "Hero with Image", desc: "\uC774\uBBF8\uC9C0 \uBC30\uACBD \uD788\uC5B4\uB85C" },
+    { id: "hero-centered", name: "Hero Centered", desc: "\uC911\uC559 \uC815\uB82C \uD788\uC5B4\uB85C" },
+    { id: "hero-split", name: "Hero Split", desc: "\uBD84\uD560 \uB808\uC774\uC544\uC6C3 \uD788\uC5B4\uB85C" },
+    { id: "hero-gradient", name: "Hero Gradient", desc: "\uADF8\uB77C\uB370\uC774\uC158 \uD788\uC5B4\uB85C" }
+  ],
+  feature: [
+    { id: "feature-grid", name: "Feature Grid", desc: "\uADF8\uB9AC\uB4DC \uD615\uC2DD \uAE30\uB2A5 \uC18C\uAC1C" },
+    { id: "feature-alternating", name: "Feature Alternating", desc: "\uAD50\uCC28 \uB808\uC774\uC544\uC6C3" },
+    { id: "feature-icons", name: "Feature Icons", desc: "\uC544\uC774\uCF58 \uAE30\uBC18 \uAE30\uB2A5" },
+    { id: "feature-cards", name: "Feature Cards", desc: "\uCE74\uB4DC \uD615\uC2DD \uAE30\uB2A5" }
+  ],
+  pricing: [
+    { id: "pricing-three-tiers", name: "Pricing Three Tiers", desc: "3\uB2E8 \uC694\uAE08\uC81C" },
+    { id: "pricing-comparison", name: "Pricing Comparison", desc: "\uBE44\uAD50 \uD14C\uC774\uBE14" },
+    { id: "pricing-toggle", name: "Pricing Toggle", desc: "\uC6D4/\uC5F0 \uD1A0\uAE00 \uC694\uAE08\uC81C" }
+  ],
+  landing: [
+    { id: "deepcon-ai-landing", name: "Deepcon AI Landing", desc: "AI SaaS \uB79C\uB529" },
+    { id: "saas-landing", name: "SaaS Landing", desc: "SaaS \uC2A4\uD0C0\uD130 \uB79C\uB529" },
+    { id: "agency-landing", name: "Agency Landing", desc: "\uC5D0\uC774\uC804\uC2DC \uB79C\uB529" }
+  ],
+  testimonial: [
+    { id: "testimonial-carousel", name: "Testimonial Carousel", desc: "\uCE90\uB7EC\uC140 \uD6C4\uAE30" },
+    { id: "testimonial-grid", name: "Testimonial Grid", desc: "\uADF8\uB9AC\uB4DC \uD6C4\uAE30" },
+    { id: "testimonial-quote", name: "Testimonial Quote", desc: "\uC778\uC6A9\uAD6C \uD6C4\uAE30" }
+  ],
+  cta: [
+    { id: "cta-simple", name: "CTA Simple", desc: "\uC2EC\uD50C CTA" },
+    { id: "cta-with-image", name: "CTA with Image", desc: "\uC774\uBBF8\uC9C0 CTA" },
+    { id: "cta-newsletter", name: "CTA Newsletter", desc: "\uB274\uC2A4\uB808\uD130 CTA" }
+  ]
+};
+var MonetCollector = class extends BaseCollector {
+  sourceType = "monet";
+  baseUrl = "https://www.monet.design";
+  registryUrl = "https://registry.monet.design";
+  constructor(options = {}) {
+    super();
+  }
+  /**
+   * 컴포넌트 목록 조회
+   * Monet은 공개 API가 제한적이므로 정적 메타데이터 반환
+   */
+  async listComponents() {
+    const items = [];
+    for (const category of MONET_CATEGORIES) {
+      const examples = MONET_EXAMPLES[category.id] || [];
+      for (const example of examples) {
+        items.push({
+          id: `monet-${example.id}`,
+          name: example.name,
+          description: example.desc,
+          category: this.mapMonetCategory(category.id),
+          source: "monet"
+        });
+      }
+      items.push({
+        id: `monet-${category.id}`,
+        name: category.name,
+        description: `${category.desc} (${category.count}\uAC1C \uCEF4\uD3EC\uB10C\uD2B8)`,
+        category: this.mapMonetCategory(category.id),
+        source: "monet"
+      });
+    }
+    return items;
+  }
+  /**
+   * 단일 컴포넌트 수집
+   * Monet API 제한으로 메타데이터만 반환
+   */
+  async collectComponent(id) {
+    const name = id.replace("monet-", "");
+    const category = MONET_CATEGORIES.find((c) => c.id === name);
+    let example;
+    for (const [catId, examples] of Object.entries(MONET_EXAMPLES)) {
+      const found = examples.find((e) => e.id === name);
+      if (found) {
+        example = found;
+        break;
+      }
+    }
+    const displayName = example?.name || category?.name || name;
+    const description = example?.desc || category?.desc || `Monet ${name} component`;
+    const monetCategory = category?.id || this.findCategoryForExample(name);
+    return this.createBaseMeta(displayName, description, [], {
+      registry: "@monet",
+      url: `${this.baseUrl}/c?category=${monetCategory || name}`
+    });
+  }
+  /**
+   * Monet 카테고리를 AXIS 카테고리로 매핑
+   */
+  mapMonetCategory(monetCategory) {
+    const mapping = {
+      hero: "layout",
+      feature: "data-display",
+      testimonial: "data-display",
+      pricing: "data-display",
+      cta: "ui",
+      stats: "data-display",
+      footer: "navigation",
+      header: "navigation",
+      "logo-cloud": "data-display",
+      team: "data-display",
+      faq: "data-display",
+      contact: "form",
+      newsletter: "form",
+      landing: "layout"
+    };
+    return mapping[monetCategory] || "ui";
+  }
+  /**
+   * 예시 컴포넌트의 카테고리 찾기
+   */
+  findCategoryForExample(exampleId) {
+    for (const [catId, examples] of Object.entries(MONET_EXAMPLES)) {
+      if (examples.some((e) => e.id === exampleId)) {
+        return catId;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * 레지스트리 URL에서 컴포넌트 정보 조회 시도
+   */
+  async tryFetchFromRegistry(name) {
+    try {
+      const response = await fetch(`${this.registryUrl}/${name}.json`);
+      if (response.ok) {
+        return await response.json();
+      }
+    } catch {
+    }
+    return null;
+  }
+  /**
+   * 카테고리 목록 반환
+   */
+  getCategories() {
+    return MONET_CATEGORIES;
+  }
+  /**
+   * 카테고리별 컴포넌트 수 반환
+   */
+  getCategoryCount(categoryId) {
+    const category = MONET_CATEGORIES.find((c) => c.id === categoryId);
+    return category?.count || 0;
+  }
+};
+
+// src/library/v0-collector.ts
+import fs from "fs-extra";
+import path from "path";
+var V0_PATTERNS = [
+  /@\/components\/ui\//,
+  /from ['"]@\/lib\/utils['"]/,
+  /from ['"]lucide-react['"]/
+];
+var V0Collector = class extends BaseCollector {
+  sourceType = "v0";
+  v0Directory;
+  convertToAxis;
+  constructor(options = {}) {
+    super();
+    this.v0Directory = options.directory || "./src/components/v0";
+    this.convertToAxis = options.convertToAxis ?? true;
+  }
+  /**
+   * V0 디렉토리에서 컴포넌트 목록 조회
+   */
+  async listComponents() {
+    const items = [];
+    if (!await fs.pathExists(this.v0Directory)) {
+      return items;
+    }
+    const files = await this.scanDirectory(this.v0Directory);
+    for (const file of files) {
+      const content = await fs.readFile(file, "utf-8");
+      if (this.isV0Code(content)) {
+        const name = path.basename(file, path.extname(file));
+        const relativePath = path.relative(this.v0Directory, file);
+        items.push({
+          id: `v0-${this.generateSlug(name)}`,
+          name: this.formatName(name),
+          description: this.extractDescription(content) || `V0 generated ${name} component`,
+          category: this.classifyCategory(name, content),
+          source: "v0"
+        });
+      }
+    }
+    return items;
+  }
+  /**
+   * 단일 컴포넌트 수집
+   */
+  async collectComponent(id) {
+    const slug = id.replace("v0-", "");
+    const files = await this.findComponentFiles(slug);
+    if (files.length === 0) {
+      throw new Error(`V0 component not found: ${slug}`);
+    }
+    const codeFiles = [];
+    for (const filePath of files) {
+      let content = await fs.readFile(filePath, "utf-8");
+      if (this.convertToAxis) {
+        content = this.convertCode(content);
+      }
+      codeFiles.push({
+        path: path.relative(this.v0Directory, filePath),
+        content,
+        type: this.getFileType(filePath)
+      });
+    }
+    const mainContent = codeFiles.map((f) => f.content).join("\n");
+    const name = this.formatName(slug);
+    return this.createBaseMeta(
+      name,
+      this.extractDescription(mainContent) || `V0 generated ${name} component`,
+      codeFiles,
+      {
+        registry: "@v0",
+        url: "https://v0.app"
+      }
+    );
+  }
+  /**
+   * V0 코드인지 확인
+   */
+  isV0Code(code) {
+    return V0_PATTERNS.some((pattern) => pattern.test(code));
+  }
+  /**
+   * V0 코드를 AXIS 스타일로 변환
+   */
+  convertCode(code) {
+    let result = code;
+    const conversions = [
+      { from: /@\/components\/ui\/button/g, to: "@axis-ds/ui-react/button" },
+      { from: /@\/components\/ui\/card/g, to: "@axis-ds/ui-react/card" },
+      { from: /@\/components\/ui\/input/g, to: "@axis-ds/ui-react/input" },
+      { from: /@\/components\/ui\/badge/g, to: "@axis-ds/ui-react/badge" },
+      { from: /@\/components\/ui\/dialog/g, to: "@axis-ds/ui-react/dialog" },
+      { from: /@\/components\/ui\/select/g, to: "@axis-ds/ui-react/select" },
+      { from: /@\/components\/ui\/tabs/g, to: "@axis-ds/ui-react/tabs" },
+      { from: /@\/components\/ui\/label/g, to: "@axis-ds/ui-react/label" },
+      { from: /@\/components\/ui\/separator/g, to: "@axis-ds/ui-react/separator" },
+      { from: /@\/components\/ui\/toast/g, to: "@axis-ds/ui-react/toast" },
+      // 일반 패턴
+      { from: /@\/components\/ui\/([a-z-]+)/g, to: "@axis-ds/ui-react/$1" }
+    ];
+    for (const { from, to } of conversions) {
+      result = result.replace(from, to);
+    }
+    if (result.includes("cn(") && !result.includes('from "@/lib/utils"')) {
+      result = `import { cn } from "@/lib/utils";
+${result}`;
+    }
+    return result;
+  }
+  /**
+   * 디렉토리 스캔
+   */
+  async scanDirectory(dir) {
+    const files = [];
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (!entry.name.startsWith(".") && entry.name !== "node_modules") {
+          files.push(...await this.scanDirectory(fullPath));
+        }
+      } else if (entry.name.endsWith(".tsx") || entry.name.endsWith(".ts")) {
+        files.push(fullPath);
+      }
+    }
+    return files;
+  }
+  /**
+   * 컴포넌트 파일 찾기
+   */
+  async findComponentFiles(slug) {
+    const files = [];
+    const possiblePaths = [
+      path.join(this.v0Directory, `${slug}.tsx`),
+      path.join(this.v0Directory, slug, `index.tsx`),
+      path.join(this.v0Directory, slug, `${slug}.tsx`)
+    ];
+    for (const filePath of possiblePaths) {
+      if (await fs.pathExists(filePath)) {
+        files.push(filePath);
+        const dir = path.dirname(filePath);
+        if (dir !== this.v0Directory) {
+          const dirFiles = await fs.readdir(dir);
+          for (const f of dirFiles) {
+            if ((f.endsWith(".tsx") || f.endsWith(".ts")) && !files.includes(path.join(dir, f))) {
+              files.push(path.join(dir, f));
+            }
+          }
+        }
+        break;
+      }
+    }
+    return files;
+  }
+  /**
+   * 설명 추출 (JSDoc 주석에서)
+   */
+  extractDescription(code) {
+    const jsdocMatch = code.match(/\/\*\*\s*\n\s*\*\s*(.+)\n/);
+    if (jsdocMatch) {
+      return jsdocMatch[1].trim();
+    }
+    const commentMatch = code.match(/^\/\/\s*(.+)$/m);
+    if (commentMatch) {
+      return commentMatch[1].trim();
+    }
+    return void 0;
+  }
+  /**
+   * 이름 포맷팅
+   */
+  formatName(slug) {
+    return slug.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+  }
+  /**
+   * 파일 타입 추론
+   */
+  getFileType(filePath) {
+    const name = path.basename(filePath);
+    if (name.startsWith("use") || name.includes("hook")) return "hook";
+    if (name.includes("util") || name.includes("lib")) return "util";
+    if (name.endsWith(".css")) return "style";
+    if (name.endsWith(".d.ts") || name.includes("types")) return "type";
+    return "component";
+  }
+  /**
+   * V0 디렉토리 설정
+   */
+  setDirectory(directory) {
+    this.v0Directory = directory;
+  }
+  /**
+   * AXIS 변환 설정
+   */
+  setConvertToAxis(convert) {
+    this.convertToAxis = convert;
+  }
+};
+
+// src/library/axis-collector.ts
+import fs2 from "fs-extra";
+import path2 from "path";
+var DEFAULT_PATHS = {
+  uiReact: "packages/axis-ui-react/src",
+  agenticUi: "packages/axis-agentic-ui/src",
+  webComponents: "apps/web/src/app/components",
+  webAgentic: "apps/web/src/app/agentic"
+};
+var AxisCollector = class extends BaseCollector {
+  sourceType = "axis";
+  rootDir;
+  paths;
+  constructor(options = {}) {
+    super();
+    this.rootDir = options.rootDir || process.cwd();
+    this.paths = { ...DEFAULT_PATHS, ...options.paths };
+  }
+  /**
+   * AXIS 컴포넌트 목록 조회
+   */
+  async listComponents() {
+    const items = [];
+    items.push(...await this.scanPackage(this.paths.uiReact, "ui", "@axis-ds/ui-react"));
+    items.push(...await this.scanPackage(this.paths.agenticUi, "agentic", "@axis-ds/agentic-ui"));
+    items.push(...await this.scanWebDirectory(this.paths.webComponents, "ui"));
+    items.push(...await this.scanWebDirectory(this.paths.webAgentic, "agentic"));
+    const uniqueItems = /* @__PURE__ */ new Map();
+    for (const item of items) {
+      if (!uniqueItems.has(item.id)) {
+        uniqueItems.set(item.id, item);
+      }
+    }
+    return [...uniqueItems.values()];
+  }
+  /**
+   * 단일 컴포넌트 수집
+   */
+  async collectComponent(id) {
+    const slug = id.replace("axis-", "");
+    const componentInfo = await this.findComponent(slug);
+    if (!componentInfo) {
+      throw new Error(`AXIS component not found: ${slug}`);
+    }
+    const codeFiles = [];
+    for (const filePath of componentInfo.files) {
+      const content = await fs2.readFile(filePath, "utf-8");
+      codeFiles.push({
+        path: path2.relative(componentInfo.baseDir, filePath),
+        content,
+        type: this.getFileType(filePath)
+      });
+    }
+    const mainContent = codeFiles.map((f) => f.content).join("\n");
+    const meta = this.createBaseMeta(
+      componentInfo.name,
+      this.extractDescription(mainContent) || `AXIS ${componentInfo.name} component`,
+      codeFiles,
+      {
+        registry: "@axis",
+        url: this.getDocsUrl(slug, componentInfo.category)
+      }
+    );
+    meta.category = componentInfo.category;
+    return meta;
+  }
+  /**
+   * 패키지 디렉토리 스캔
+   */
+  async scanPackage(packagePath, defaultCategory, registry) {
+    const items = [];
+    const fullPath = path2.join(this.rootDir, packagePath);
+    if (!await fs2.pathExists(fullPath)) {
+      return items;
+    }
+    const entries = await fs2.readdir(fullPath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const componentDir = path2.join(fullPath, entry.name);
+        const indexFile = path2.join(componentDir, "index.tsx");
+        if (await fs2.pathExists(indexFile)) {
+          const content = await fs2.readFile(indexFile, "utf-8");
+          const name = this.formatName(entry.name);
+          items.push({
+            id: `axis-${entry.name}`,
+            name,
+            description: this.extractDescription(content) || `AXIS ${name} component`,
+            category: this.classifyCategory(entry.name, content) || defaultCategory,
+            source: "axis"
+          });
+        }
+      } else if (entry.name.endsWith(".tsx") && entry.name !== "index.tsx") {
+        const name = entry.name.replace(".tsx", "");
+        const filePath = path2.join(fullPath, entry.name);
+        const content = await fs2.readFile(filePath, "utf-8");
+        items.push({
+          id: `axis-${name}`,
+          name: this.formatName(name),
+          description: this.extractDescription(content) || `AXIS ${name} component`,
+          category: this.classifyCategory(name, content) || defaultCategory,
+          source: "axis"
+        });
+      }
+    }
+    return items;
+  }
+  /**
+   * Web 디렉토리 스캔 (app router 구조)
+   */
+  async scanWebDirectory(webPath, defaultCategory) {
+    const items = [];
+    const fullPath = path2.join(this.rootDir, webPath);
+    if (!await fs2.pathExists(fullPath)) {
+      return items;
+    }
+    const entries = await fs2.readdir(fullPath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const componentDir = path2.join(fullPath, entry.name);
+        const pageFile = path2.join(componentDir, "page.tsx");
+        if (await fs2.pathExists(pageFile)) {
+          const content = await fs2.readFile(pageFile, "utf-8");
+          const name = this.formatName(entry.name);
+          items.push({
+            id: `axis-${entry.name}`,
+            name,
+            description: this.extractDescription(content) || `AXIS ${name} component`,
+            category: this.classifyCategory(entry.name, content) || defaultCategory,
+            source: "axis"
+          });
+        }
+      }
+    }
+    return items;
+  }
+  /**
+   * 컴포넌트 찾기
+   */
+  async findComponent(slug) {
+    const searchPaths = [
+      { base: this.paths.uiReact, category: "ui" },
+      { base: this.paths.agenticUi, category: "agentic" },
+      { base: this.paths.webComponents, category: "ui" },
+      { base: this.paths.webAgentic, category: "agentic" }
+    ];
+    for (const { base, category } of searchPaths) {
+      const fullBase = path2.join(this.rootDir, base);
+      const dirPath = path2.join(fullBase, slug);
+      if (await fs2.pathExists(dirPath)) {
+        const files = await this.getComponentFiles(dirPath);
+        if (files.length > 0) {
+          return {
+            name: this.formatName(slug),
+            files,
+            baseDir: dirPath,
+            category
+          };
+        }
+      }
+      const filePath = path2.join(fullBase, `${slug}.tsx`);
+      if (await fs2.pathExists(filePath)) {
+        return {
+          name: this.formatName(slug),
+          files: [filePath],
+          baseDir: fullBase,
+          category
+        };
+      }
+    }
+    return null;
+  }
+  /**
+   * 컴포넌트 디렉토리에서 파일 목록 가져오기
+   */
+  async getComponentFiles(dir) {
+    const files = [];
+    const entries = await fs2.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isFile() && (entry.name.endsWith(".tsx") || entry.name.endsWith(".ts"))) {
+        files.push(path2.join(dir, entry.name));
+      }
+    }
+    return files;
+  }
+  /**
+   * 설명 추출
+   */
+  extractDescription(code) {
+    const jsdocMatch = code.match(/\/\*\*\s*\n\s*\*\s*(.+)\n/);
+    if (jsdocMatch) {
+      return jsdocMatch[1].trim();
+    }
+    const commentMatch = code.match(/^\/\/\s*(.+)$/m);
+    if (commentMatch) {
+      return commentMatch[1].trim();
+    }
+    return void 0;
+  }
+  /**
+   * 이름 포맷팅
+   */
+  formatName(slug) {
+    return slug.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+  }
+  /**
+   * 파일 타입 추론
+   */
+  getFileType(filePath) {
+    const name = path2.basename(filePath);
+    if (name.startsWith("use") || name.includes("hook")) return "hook";
+    if (name.includes("util") || name.includes("lib")) return "util";
+    if (name.endsWith(".css")) return "style";
+    if (name.endsWith(".d.ts") || name.includes("types")) return "type";
+    return "component";
+  }
+  /**
+   * 문서 URL 생성
+   */
+  getDocsUrl(slug, category) {
+    const baseUrl = "https://axis.minu.best";
+    return `${baseUrl}/${category}/${slug}`;
+  }
+};
+
+// src/library/publisher.ts
+import fs3 from "fs-extra";
+import path3 from "path";
+import chalk from "chalk";
+import ora from "ora";
+var Publisher = class {
+  defaultOutputDir = "apps/web/public/library";
+  /**
+   * 라이브러리 인덱스를 사이트에 배치
+   */
+  async publish(index, options = {}) {
+    const outputDir = options.outputDir || this.defaultOutputDir;
+    const files = [];
+    const errors = [];
+    const spinner = ora("\uB77C\uC774\uBE0C\uB7EC\uB9AC \uBC30\uCE58 \uC911...").start();
+    try {
+      await fs3.ensureDir(outputDir);
+      const indexPath = path3.join(outputDir, "index.json");
+      await this.writeJson(indexPath, this.createPublicIndex(index), options.minify);
+      files.push(indexPath);
+      const categoriesDir = path3.join(outputDir, "categories");
+      await fs3.ensureDir(categoriesDir);
+      for (const category of index.categories) {
+        const categoryComponents = index.components.filter((c) => c.category === category.id);
+        const categoryPath = path3.join(categoriesDir, `${category.id}.json`);
+        await this.writeJson(
+          categoryPath,
+          {
+            category: category.id,
+            name: category.name,
+            description: category.description,
+            icon: category.icon,
+            count: categoryComponents.length,
+            components: categoryComponents.map((c) => this.createPublicComponent(c))
+          },
+          options.minify
+        );
+        files.push(categoryPath);
+      }
+      const componentsDir = path3.join(outputDir, "components");
+      await fs3.ensureDir(componentsDir);
+      for (const component of index.components) {
+        const componentPath = path3.join(componentsDir, `${component.slug}.json`);
+        await this.writeJson(componentPath, this.createPublicComponent(component), options.minify);
+        files.push(componentPath);
+      }
+      let searchIndexSize = 0;
+      if (options.generateSearchIndex !== false) {
+        const searchIndex = this.generateSearchIndex(index);
+        const searchPath = path3.join(outputDir, "search-index.json");
+        await this.writeJson(searchPath, searchIndex, options.minify);
+        files.push(searchPath);
+        searchIndexSize = searchIndex.length;
+      }
+      const metaPath = path3.join(outputDir, "meta.json");
+      await this.writeJson(
+        metaPath,
+        {
+          version: index.version,
+          updatedAt: index.updatedAt,
+          stats: index.stats,
+          categories: index.categories,
+          tags: index.tags.slice(0, 50)
+          // 상위 50개 태그만
+        },
+        options.minify
+      );
+      files.push(metaPath);
+      spinner.succeed(`\uB77C\uC774\uBE0C\uB7EC\uB9AC \uBC30\uCE58 \uC644\uB8CC: ${files.length}\uAC1C \uD30C\uC77C`);
+      return {
+        success: true,
+        outputDir,
+        files,
+        stats: {
+          totalComponents: index.components.length,
+          categoriesPublished: index.categories.length,
+          searchIndexSize
+        },
+        errors
+      };
+    } catch (error) {
+      spinner.fail("\uB77C\uC774\uBE0C\uB7EC\uB9AC \uBC30\uCE58 \uC2E4\uD328");
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      errors.push(errorMessage);
+      return {
+        success: false,
+        outputDir,
+        files,
+        stats: {
+          totalComponents: 0,
+          categoriesPublished: 0,
+          searchIndexSize: 0
+        },
+        errors
+      };
+    }
+  }
+  /**
+   * 공개용 인덱스 생성 (코드 제외)
+   */
+  createPublicIndex(index) {
+    return {
+      version: index.version,
+      updatedAt: index.updatedAt,
+      stats: index.stats,
+      categories: index.categories,
+      components: index.components.map((c) => ({
+        id: c.id,
+        slug: c.slug,
+        name: c.name,
+        description: c.description,
+        category: c.category,
+        source: c.source.type,
+        tags: c.tags,
+        status: c.status
+      }))
+    };
+  }
+  /**
+   * 공개용 컴포넌트 생성
+   */
+  createPublicComponent(component) {
+    return {
+      id: component.id,
+      slug: component.slug,
+      name: component.name,
+      description: component.description,
+      category: component.category,
+      source: {
+        type: component.source.type,
+        registry: component.source.registry,
+        url: component.source.url
+      },
+      tags: component.tags,
+      code: component.code,
+      preview: component.preview,
+      dependencies: component.dependencies,
+      status: component.status,
+      updatedAt: component.updatedAt
+    };
+  }
+  /**
+   * 검색 인덱스 생성
+   */
+  generateSearchIndex(index) {
+    return index.components.map((c) => ({
+      id: c.id,
+      slug: c.slug,
+      name: c.name,
+      description: c.description,
+      category: c.category,
+      source: c.source.type,
+      tags: c.tags,
+      url: `/library/${c.category}/${c.slug}`
+    }));
+  }
+  /**
+   * JSON 파일 쓰기
+   */
+  async writeJson(filePath, data, minify) {
+    const content = minify ? JSON.stringify(data) : JSON.stringify(data, null, 2);
+    await fs3.writeFile(filePath, content, "utf-8");
+  }
+  /**
+   * 기존 배치 정리
+   */
+  async clean(outputDir) {
+    const dir = outputDir || this.defaultOutputDir;
+    if (await fs3.pathExists(dir)) {
+      await fs3.remove(dir);
+      console.log(chalk.yellow(`\u2713 \uAE30\uC874 \uBC30\uCE58 \uC815\uB9AC: ${dir}`));
+    }
+  }
+  /**
+   * 배치 상태 확인
+   */
+  async getStatus(outputDir) {
+    const dir = outputDir || this.defaultOutputDir;
+    const metaPath = path3.join(dir, "meta.json");
+    if (!await fs3.pathExists(metaPath)) {
+      return { exists: false };
+    }
+    try {
+      const meta = await fs3.readJson(metaPath);
+      return {
+        exists: true,
+        lastUpdated: meta.updatedAt,
+        componentCount: meta.stats?.total
+      };
+    } catch {
+      return { exists: false };
+    }
+  }
+};
+var publisher = new Publisher();
+
+// src/library/index.ts
+import fs4 from "fs-extra";
+import path4 from "path";
+import chalk2 from "chalk";
+import ora2 from "ora";
+var DEFAULT_CATEGORIES = [
+  { id: "ui", name: "UI", description: "\uAE30\uBCF8 UI \uCEF4\uD3EC\uB10C\uD2B8", icon: "layers", order: 1 },
+  { id: "agentic", name: "Agentic", description: "Agentic UI \uCEF4\uD3EC\uB10C\uD2B8", icon: "bot", order: 2 },
+  { id: "form", name: "Form", description: "\uD3FC \uCEF4\uD3EC\uB10C\uD2B8", icon: "text-cursor-input", order: 3 },
+  { id: "layout", name: "Layout", description: "\uB808\uC774\uC544\uC6C3 \uCEF4\uD3EC\uB10C\uD2B8", icon: "layout", order: 4 },
+  { id: "navigation", name: "Navigation", description: "\uB124\uBE44\uAC8C\uC774\uC158", icon: "navigation", order: 5 },
+  { id: "feedback", name: "Feedback", description: "\uD53C\uB4DC\uBC31 \uCEF4\uD3EC\uB10C\uD2B8", icon: "bell", order: 6 },
+  { id: "overlay", name: "Overlay", description: "\uC624\uBC84\uB808\uC774 \uCEF4\uD3EC\uB10C\uD2B8", icon: "square-stack", order: 7 },
+  { id: "data-display", name: "Data Display", description: "\uB370\uC774\uD130 \uD45C\uC2DC", icon: "table", order: 8 },
+  { id: "chart", name: "Chart", description: "\uCC28\uD2B8/\uC2DC\uAC01\uD654", icon: "chart-bar", order: 9 },
+  { id: "utility", name: "Utility", description: "\uC720\uD2F8\uB9AC\uD2F0", icon: "wrench", order: 10 }
+];
+var LibraryCurator = class {
+  collectors = /* @__PURE__ */ new Map();
+  dataDir;
+  constructor(options = {}) {
+    this.dataDir = options.dataDir || ".claude/data/library";
+    this.collectors.set("shadcn", new ShadcnCollector());
+    this.collectors.set("monet", new MonetCollector());
+    this.collectors.set("v0", new V0Collector());
+    this.collectors.set("axis", new AxisCollector({ rootDir: options.rootDir }));
+  }
+  /**
+   * 전체 수집 실행
+   */
+  async collectAll(sources, options) {
+    const results = /* @__PURE__ */ new Map();
+    const targetSources = sources || ["shadcn", "monet", "v0", "axis"];
+    console.log(chalk2.blue("\n\u{1F4E6} Library Curator - \uCEF4\uD3EC\uB10C\uD2B8 \uC218\uC9D1 \uC2DC\uC791\n"));
+    for (const source of targetSources) {
+      const collector = this.collectors.get(source);
+      if (!collector) {
+        console.log(chalk2.yellow(`\u26A0\uFE0F  ${source} collector not found, skipping`));
+        continue;
+      }
+      const spinner = ora2(`${source} \uC218\uC9D1 \uC911...`).start();
+      try {
+        const result = await collector.collectAll({
+          incremental: options?.incremental
+        });
+        results.set(source, result);
+        if (result.success) {
+          spinner.succeed(
+            `${source}: ${result.collected}\uAC1C \uC218\uC9D1 \uC644\uB8CC` + (result.failed > 0 ? chalk2.yellow(` (${result.failed}\uAC1C \uC2E4\uD328)`) : "")
+          );
+        } else {
+          spinner.fail(`${source}: \uC218\uC9D1 \uC2E4\uD328 - ${result.errors[0]?.error}`);
+        }
+      } catch (error) {
+        spinner.fail(`${source}: ${error instanceof Error ? error.message : "Unknown error"}`);
+        results.set(source, {
+          source,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          success: false,
+          collected: 0,
+          updated: 0,
+          failed: 1,
+          items: [],
+          errors: [
+            {
+              id: "root",
+              error: error instanceof Error ? error.message : "Unknown error",
+              recoverable: false
+            }
+          ]
+        });
+      }
+    }
+    return results;
+  }
+  /**
+   * 라이브러리 인덱스 생성
+   */
+  async generateIndex() {
+    const components = [];
+    for (const [source, collector] of this.collectors) {
+      try {
+        const list = await collector.listComponents();
+        for (const item of list) {
+          try {
+            const meta = await collector.collectComponent(item.id);
+            components.push(meta);
+          } catch {
+          }
+        }
+      } catch {
+      }
+    }
+    const stats = this.calculateStats(components);
+    const tags = this.aggregateTags(components);
+    return {
+      version: "1.0.0",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      stats,
+      components,
+      categories: DEFAULT_CATEGORIES,
+      tags
+    };
+  }
+  /**
+   * 인덱스 저장
+   */
+  async saveIndex(index) {
+    await fs4.ensureDir(this.dataDir);
+    const indexPath = path4.join(this.dataDir, "components.json");
+    await fs4.writeJSON(indexPath, index, { spaces: 2 });
+    const categoriesDir = path4.join(this.dataDir, "categories");
+    await fs4.ensureDir(categoriesDir);
+    for (const category of DEFAULT_CATEGORIES) {
+      const categoryComponents = index.components.filter((c) => c.category === category.id);
+      const categoryPath = path4.join(categoriesDir, `${category.id}.json`);
+      await fs4.writeJSON(
+        categoryPath,
+        {
+          category: category.id,
+          count: categoryComponents.length,
+          components: categoryComponents
+        },
+        { spaces: 2 }
+      );
+    }
+    console.log(chalk2.green(`
+\u2713 \uC778\uB371\uC2A4 \uC800\uC7A5 \uC644\uB8CC: ${indexPath}`));
+    console.log(chalk2.gray(`  - \uC804\uCCB4: ${index.stats.total}\uAC1C \uCEF4\uD3EC\uB10C\uD2B8`));
+  }
+  /**
+   * 인덱스 로드
+   */
+  async loadIndex() {
+    const indexPath = path4.join(this.dataDir, "components.json");
+    if (await fs4.pathExists(indexPath)) {
+      return await fs4.readJSON(indexPath);
+    }
+    return null;
+  }
+  /**
+   * 통계 계산
+   */
+  calculateStats(components) {
+    const bySource = {};
+    const byCategory = {};
+    for (const comp of components) {
+      bySource[comp.source.type] = (bySource[comp.source.type] || 0) + 1;
+      byCategory[comp.category] = (byCategory[comp.category] || 0) + 1;
+    }
+    return {
+      total: components.length,
+      bySource,
+      byCategory
+    };
+  }
+  /**
+   * 태그 집계
+   */
+  aggregateTags(components) {
+    const tagCounts = /* @__PURE__ */ new Map();
+    for (const comp of components) {
+      for (const tag of comp.tags) {
+        tagCounts.set(tag, (tagCounts.get(tag) || 0) + 1);
+      }
+    }
+    return [...tagCounts.entries()].map(([id, count]) => ({ id, name: id, count })).sort((a, b) => b.count - a.count);
+  }
+  /**
+   * 컴포넌트 검색
+   */
+  async searchComponents(query, options) {
+    const index = await this.loadIndex();
+    if (!index) return [];
+    const queryLower = query.toLowerCase();
+    return index.components.filter((comp) => {
+      if (options?.category && comp.category !== options.category) {
+        return false;
+      }
+      if (options?.source && comp.source.type !== options.source) {
+        return false;
+      }
+      return comp.name.toLowerCase().includes(queryLower) || comp.description.toLowerCase().includes(queryLower) || comp.tags.some((t) => t.toLowerCase().includes(queryLower));
+    });
+  }
+  /**
+   * 통계 출력
+   */
+  async printStats() {
+    const index = await this.loadIndex();
+    if (!index) {
+      console.log(chalk2.yellow("\n\u26A0\uFE0F  \uB77C\uC774\uBE0C\uB7EC\uB9AC \uC778\uB371\uC2A4\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4."));
+      console.log(chalk2.gray("   axis-cli library collect \uBA85\uB839\uC5B4\uB85C \uC218\uC9D1\uC744 \uBA3C\uC800 \uC2E4\uD589\uD558\uC138\uC694.\n"));
+      return;
+    }
+    console.log(chalk2.blue("\n\u{1F4CA} Library Curator - \uD1B5\uACC4\n"));
+    console.log(chalk2.bold("\uC804\uCCB4 \uCEF4\uD3EC\uB10C\uD2B8: ") + chalk2.cyan(`${index.stats.total}\uAC1C`));
+    console.log(chalk2.gray(`\uB9C8\uC9C0\uB9C9 \uC5C5\uB370\uC774\uD2B8: ${index.updatedAt}
+`));
+    console.log(chalk2.bold("\uC18C\uC2A4\uBCC4:"));
+    for (const [source, count] of Object.entries(index.stats.bySource)) {
+      console.log(`  ${chalk2.cyan(source.padEnd(10))} ${count}\uAC1C`);
+    }
+    console.log(chalk2.bold("\n\uCE74\uD14C\uACE0\uB9AC\uBCC4:"));
+    for (const [category, count] of Object.entries(index.stats.byCategory)) {
+      console.log(`  ${chalk2.cyan(category.padEnd(15))} ${count}\uAC1C`);
+    }
+    console.log(chalk2.bold("\n\uC778\uAE30 \uD0DC\uADF8:"));
+    const topTags = index.tags.slice(0, 10);
+    for (const tag of topTags) {
+      console.log(`  ${chalk2.cyan(tag.name.padEnd(15))} ${tag.count}\uAC1C`);
+    }
+    console.log();
+  }
+};
+var libraryCurator = new LibraryCurator();
+
+// src/template/index.ts
+import chalk7 from "chalk";
+import ora5 from "ora";
+
+// src/template/template-apply.ts
+import fs6 from "fs-extra";
+import path6 from "path";
+import chalk4 from "chalk";
+import ora3 from "ora";
+import prompts from "prompts";
+
+// src/template/post-install.ts
+import fs5 from "fs-extra";
+import path5 from "path";
+import chalk3 from "chalk";
+async function runPostInstall(patches, baseDir, dryRun = false) {
+  for (const patch of patches) {
+    const filePath = path5.resolve(baseDir, patch.file);
+    if (dryRun) {
+      console.log(chalk3.gray(`  [dry-run] patch ${patch.type}: ${patch.file}`));
+      continue;
+    }
+    if (!await fs5.pathExists(filePath)) {
+      console.log(chalk3.yellow(`  \uACBD\uACE0: \uD328\uCE58 \uB300\uC0C1 \uD30C\uC77C \uC5C6\uC74C - ${patch.file}`));
+      continue;
+    }
+    switch (patch.type) {
+      case "replace": {
+        if (!patch.search || patch.value === void 0) break;
+        let content = await fs5.readFile(filePath, "utf-8");
+        content = content.replace(patch.search, patch.value);
+        await fs5.writeFile(filePath, content);
+        console.log(chalk3.gray(`  patch replace: ${patch.file}`));
+        break;
+      }
+      case "append": {
+        if (patch.value === void 0) break;
+        const content = await fs5.readFile(filePath, "utf-8");
+        await fs5.writeFile(filePath, content + patch.value);
+        console.log(chalk3.gray(`  patch append: ${patch.file}`));
+        break;
+      }
+      case "prepend": {
+        if (patch.value === void 0) break;
+        const content = await fs5.readFile(filePath, "utf-8");
+        await fs5.writeFile(filePath, patch.value + content);
+        console.log(chalk3.gray(`  patch prepend: ${patch.file}`));
+        break;
+      }
+      case "json-merge": {
+        if (!patch.merge) break;
+        const raw = await fs5.readFile(filePath, "utf-8");
+        const json = JSON.parse(raw);
+        deepMerge(json, patch.merge);
+        await fs5.writeJSON(filePath, json, { spaces: 2 });
+        console.log(chalk3.gray(`  patch json-merge: ${patch.file}`));
+        break;
+      }
+    }
+  }
+}
+function deepMerge(target, source) {
+  for (const key of Object.keys(source)) {
+    const srcVal = source[key];
+    const tgtVal = target[key];
+    if (srcVal && typeof srcVal === "object" && !Array.isArray(srcVal) && tgtVal && typeof tgtVal === "object" && !Array.isArray(tgtVal)) {
+      deepMerge(tgtVal, srcVal);
+    } else {
+      target[key] = srcVal;
+    }
+  }
+}
+
+// src/template/template-apply.ts
+async function applyTemplate(slug, options) {
+  const spinner = ora3(`'${slug}' \uD15C\uD50C\uB9BF \uAC00\uC838\uC624\uB294 \uC911...`).start();
+  let detail;
+  try {
+    detail = await fetchTemplateDetail(slug);
+    spinner.succeed(`'${detail.name}' \uD15C\uD50C\uB9BF \uB85C\uB4DC \uC644\uB8CC (${detail.files.length}\uAC1C \uD30C\uC77C)`);
+  } catch (err) {
+    spinner.fail(err.message);
+    process.exit(1);
+  }
+  const baseDir = path6.resolve(options.dir || ".");
+  const conflicts = [];
+  for (const file of detail.files) {
+    const dest = path6.join(baseDir, file.path);
+    if (await fs6.pathExists(dest)) {
+      conflicts.push(file.path);
+    }
+  }
+  if (conflicts.length > 0 && !options.yes && !options.dryRun) {
+    console.log(chalk4.yellow(`
+\uAE30\uC874 \uD30C\uC77C\uACFC \uCDA9\uB3CC\uD558\uB294 ${conflicts.length}\uAC1C \uD30C\uC77C:`));
+    for (const c of conflicts) {
+      console.log(chalk4.gray(`  - ${c}`));
+    }
+    const { proceed } = await prompts({
+      type: "confirm",
+      name: "proceed",
+      message: "\uCDA9\uB3CC \uD30C\uC77C\uC744 \uB36E\uC5B4\uC4F0\uC2DC\uACA0\uC2B5\uB2C8\uAE4C?",
+      initial: false
+    });
+    if (!proceed) {
+      console.log(chalk4.gray("\uCDE8\uC18C\uB418\uC5C8\uC2B5\uB2C8\uB2E4."));
+      return;
+    }
+  }
+  if (options.dryRun) {
+    console.log(chalk4.blue("\n[\uBBF8\uB9AC\uBCF4\uAE30] \uC0DD\uC131\uB420 \uD30C\uC77C:"));
+    for (const file of detail.files) {
+      const dest = path6.join(baseDir, file.path);
+      const exists = conflicts.includes(file.path);
+      const label = exists ? chalk4.yellow("\uB36E\uC5B4\uC4F0\uAE30") : chalk4.green("\uC0DD\uC131");
+      console.log(`  ${label} ${dest}`);
+    }
+    if (detail.postInstall?.length) {
+      console.log(chalk4.blue("\n[\uBBF8\uB9AC\uBCF4\uAE30] postInstall \uD328\uCE58:"));
+      for (const p of detail.postInstall) {
+        console.log(chalk4.gray(`  ${p.type}: ${p.file}`));
+      }
+    }
+    return;
+  }
+  const writeSpinner = ora3("\uD30C\uC77C \uC0DD\uC131 \uC911...").start();
+  for (const file of detail.files) {
+    const dest = path6.join(baseDir, file.path);
+    await fs6.ensureDir(path6.dirname(dest));
+    await fs6.writeFile(dest, file.content);
+  }
+  writeSpinner.succeed(`${detail.files.length}\uAC1C \uD30C\uC77C \uC0DD\uC131 \uC644\uB8CC`);
+  if (detail.postInstall?.length) {
+    console.log(chalk4.blue("\npostInstall \uD328\uCE58 \uC2E4\uD589 \uC911..."));
+    await runPostInstall(detail.postInstall, baseDir);
+  }
+  if (!options.skipDeps) {
+    const allDeps = { ...detail.dependencies, ...detail.devDependencies };
+    const depList = Object.entries(allDeps);
+    if (depList.length > 0) {
+      console.log(chalk4.yellow("\n\uD544\uC694\uD55C \uC758\uC874\uC131:"));
+      const deps = Object.entries(detail.dependencies || {}).map(([k, v]) => `${k}@${v}`).join(" ");
+      const devDeps = Object.entries(detail.devDependencies || {}).map(([k, v]) => `${k}@${v}`).join(" ");
+      if (deps) {
+        console.log(chalk4.cyan(`  pnpm add ${deps}`));
+      }
+      if (devDeps) {
+        console.log(chalk4.cyan(`  pnpm add -D ${devDeps}`));
+      }
+    }
+  }
+  console.log(chalk4.green(`
+'${detail.name}' \uD15C\uD50C\uB9BF \uC801\uC6A9 \uC644\uB8CC!`));
+}
+async function initTemplate(slug, options) {
+  let selectedSlug = slug;
+  if (!selectedSlug) {
+    const { fetchTemplateIndex: fetchTemplateIndex2 } = await import("./registry-client-TPWFZ4HE.js");
+    const index = await fetchTemplateIndex2();
+    const { choice } = await prompts({
+      type: "select",
+      name: "choice",
+      message: "\uC0AC\uC6A9\uD560 \uD15C\uD50C\uB9BF\uC744 \uC120\uD0DD\uD558\uC138\uC694:",
+      choices: index.templates.map((t) => ({
+        title: `${t.name} (${t.category})`,
+        description: t.description,
+        value: t.slug
+      }))
+    });
+    if (!choice) {
+      console.log(chalk4.gray("\uCDE8\uC18C\uB418\uC5C8\uC2B5\uB2C8\uB2E4."));
+      return;
+    }
+    selectedSlug = choice;
+  }
+  let targetDir = options.dir;
+  if (!targetDir) {
+    const { dir } = await prompts({
+      type: "text",
+      name: "dir",
+      message: "\uD504\uB85C\uC81D\uD2B8 \uB514\uB809\uD1A0\uB9AC:",
+      initial: selectedSlug
+    });
+    if (!dir) {
+      console.log(chalk4.gray("\uCDE8\uC18C\uB418\uC5C8\uC2B5\uB2C8\uB2E4."));
+      return;
+    }
+    targetDir = dir;
+  }
+  const resolved = path6.resolve(targetDir);
+  if (await fs6.pathExists(resolved)) {
+    const entries = await fs6.readdir(resolved);
+    if (entries.length > 0) {
+      const { proceed } = await prompts({
+        type: "confirm",
+        name: "proceed",
+        message: `'${targetDir}'\uC5D0 \uC774\uBBF8 \uD30C\uC77C\uC774 \uC788\uC2B5\uB2C8\uB2E4. \uACC4\uC18D\uD558\uC2DC\uACA0\uC2B5\uB2C8\uAE4C?`,
+        initial: false
+      });
+      if (!proceed) return;
+    }
+  } else {
+    await fs6.ensureDir(resolved);
+  }
+  await applyTemplate(selectedSlug, { dir: targetDir, yes: true });
+  const configPath = path6.join(resolved, "axis.config.json");
+  if (!await fs6.pathExists(configPath)) {
+    const axisConfig = {
+      $schema: "https://ds.minu.best/schema.json",
+      template: selectedSlug,
+      componentsDir: "./components/ui",
+      tailwindConfig: "./tailwind.config.ts",
+      globalCss: "./globals.css"
+    };
+    await fs6.writeJSON(configPath, axisConfig, { spaces: 2 });
+    console.log(chalk4.green("axis.config.json \uC0DD\uC131 \uC644\uB8CC"));
+  }
+  console.log(chalk4.blue(`
+\uB2E4\uC74C \uB2E8\uACC4:`));
+  console.log(chalk4.cyan(`  cd ${targetDir}`));
+  console.log(chalk4.cyan(`  pnpm install`));
+  console.log(chalk4.cyan(`  pnpm dev`));
+}
+
+// src/template/template-diff.ts
+import fs7 from "fs-extra";
+import path7 from "path";
+import chalk5 from "chalk";
+import ora4 from "ora";
+async function diffTemplate(slug, options) {
+  const spinner = ora4(`'${slug}' \uD15C\uD50C\uB9BF \uAC00\uC838\uC624\uB294 \uC911...`).start();
+  let detail;
+  try {
+    detail = await fetchTemplateDetail(slug);
+    spinner.succeed(`'${detail.name}' \uB85C\uB4DC \uC644\uB8CC`);
+  } catch (err) {
+    spinner.fail(err.message);
+    process.exit(1);
+  }
+  const baseDir = path7.resolve(options.dir || ".");
+  const entries = [];
+  for (const file of detail.files) {
+    const localPath = path7.join(baseDir, file.path);
+    if (!await fs7.pathExists(localPath)) {
+      entries.push({ path: file.path, status: "added" });
+      continue;
+    }
+    const localContent = await fs7.readFile(localPath, "utf-8");
+    if (localContent === file.content) {
+      entries.push({ path: file.path, status: "unchanged" });
+    } else {
+      entries.push({
+        path: file.path,
+        status: "modified",
+        localLines: localContent.split("\n").length,
+        remoteLines: file.content.split("\n").length
+      });
+    }
+  }
+  if (options.verbose) {
+    const templatePaths = new Set(detail.files.map((f) => f.path));
+    const localFiles = await collectLocalFiles(baseDir);
+    for (const lf of localFiles) {
+      if (!templatePaths.has(lf)) {
+        entries.push({ path: lf, status: "extra" });
+      }
+    }
+  }
+  console.log(chalk5.blue(`
+'${detail.name}' \uD15C\uD50C\uB9BF diff \uACB0\uACFC:
+`));
+  const statusIcon = {
+    added: chalk5.green("+ \uCD94\uAC00 \uD544\uC694"),
+    modified: chalk5.yellow("~ \uBCC0\uACBD\uB428"),
+    unchanged: chalk5.gray("= \uB3D9\uC77C"),
+    extra: chalk5.cyan("? \uB85C\uCEEC \uC804\uC6A9")
+  };
+  let added = 0;
+  let modified = 0;
+  let unchanged = 0;
+  let extra = 0;
+  for (const entry of entries) {
+    const icon = statusIcon[entry.status];
+    console.log(`  ${icon.padEnd(28)} ${entry.path}`);
+    if (entry.status === "modified" && options.verbose) {
+      console.log(
+        chalk5.gray(
+          `           \uB85C\uCEEC ${entry.localLines}\uC904 / \uC6D0\uBCF8 ${entry.remoteLines}\uC904`
+        )
+      );
+    }
+    switch (entry.status) {
+      case "added":
+        added++;
+        break;
+      case "modified":
+        modified++;
+        break;
+      case "unchanged":
+        unchanged++;
+        break;
+      case "extra":
+        extra++;
+        break;
+    }
+  }
+  console.log(chalk5.blue("\n\uC694\uC57D:"));
+  console.log(
+    `  \uCD94\uAC00 \uD544\uC694: ${chalk5.green(String(added))} | \uBCC0\uACBD\uB428: ${chalk5.yellow(String(modified))} | \uB3D9\uC77C: ${chalk5.gray(String(unchanged))}${extra > 0 ? ` | \uB85C\uCEEC \uC804\uC6A9: ${chalk5.cyan(String(extra))}` : ""}`
+  );
+}
+async function collectLocalFiles(dir, base) {
+  const root = base || dir;
+  const ignore = /* @__PURE__ */ new Set(["node_modules", ".git", ".next", "dist"]);
+  const results = [];
+  let entries;
+  try {
+    entries = await fs7.readdir(dir, { withFileTypes: true });
+  } catch {
+    return results;
+  }
+  for (const entry of entries) {
+    if (ignore.has(entry.name)) continue;
+    const fullPath = path7.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      const nested = await collectLocalFiles(fullPath, root);
+      results.push(...nested);
+    } else {
+      results.push(path7.relative(root, fullPath).replace(/\\/g, "/"));
+    }
+  }
+  return results;
+}
+
+// src/template/template-check.ts
+import fs8 from "fs-extra";
+import path8 from "path";
+import chalk6 from "chalk";
+var SEVERITY_ICON = {
+  pass: chalk6.green("PASS"),
+  warn: chalk6.yellow("WARN"),
+  fail: chalk6.red("FAIL")
+};
+async function runCheck(dir) {
+  const baseDir = path8.resolve(dir || ".");
+  const results = [];
+  results.push(await checkFileExists(baseDir, "axis.config.json", "axis.config.json"));
+  results.push(await checkTailwindConfig(baseDir));
+  results.push(await checkGlobalsCss(baseDir));
+  results.push(await checkUtils(baseDir));
+  results.push(await checkDependencies(baseDir));
+  console.log(chalk6.blue("\nAXIS \uD504\uB85C\uC81D\uD2B8 \uAC80\uC99D \uACB0\uACFC:\n"));
+  let passCount = 0;
+  let warnCount = 0;
+  let failCount = 0;
+  for (const r of results) {
+    console.log(`  ${SEVERITY_ICON[r.severity]}  ${r.message}`);
+    switch (r.severity) {
+      case "pass":
+        passCount++;
+        break;
+      case "warn":
+        warnCount++;
+        break;
+      case "fail":
+        failCount++;
+        break;
+    }
+  }
+  console.log();
+  console.log(
+    `  \uACB0\uACFC: ${chalk6.green(`${passCount} pass`)} / ${chalk6.yellow(`${warnCount} warn`)} / ${chalk6.red(`${failCount} fail`)}`
+  );
+  if (failCount > 0) {
+    console.log(chalk6.red("\n\uC77C\uBD80 \uD544\uC218 \uD56D\uBAA9\uC774 \uB204\uB77D\uB418\uC5C8\uC2B5\uB2C8\uB2E4. \uC704 \uC548\uB0B4\uB97C \uD655\uC778\uD558\uC138\uC694."));
+  } else if (warnCount > 0) {
+    console.log(chalk6.yellow("\n\uAD8C\uC7A5 \uD56D\uBAA9\uC744 \uD655\uC778\uD558\uC138\uC694."));
+  } else {
+    console.log(chalk6.green("\n\uBAA8\uB4E0 \uAC80\uC99D\uC744 \uD1B5\uACFC\uD588\uC2B5\uB2C8\uB2E4!"));
+  }
+}
+async function checkFileExists(baseDir, fileName, label) {
+  const exists = await fs8.pathExists(path8.join(baseDir, fileName));
+  return {
+    name: label,
+    severity: exists ? "pass" : "fail",
+    message: exists ? `${label} \uD30C\uC77C\uC774 \uC874\uC7AC\uD569\uB2C8\uB2E4` : `${label} \uD30C\uC77C\uC774 \uC5C6\uC2B5\uB2C8\uB2E4 \u2192 'axis init'\uC744 \uC2E4\uD589\uD558\uC138\uC694`
+  };
+}
+async function checkTailwindConfig(baseDir) {
+  const tsPath = path8.join(baseDir, "tailwind.config.ts");
+  const jsPath = path8.join(baseDir, "tailwind.config.js");
+  if (await fs8.pathExists(tsPath)) {
+    const content = await fs8.readFile(tsPath, "utf-8");
+    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"
+    };
+  }
+  if (await fs8.pathExists(jsPath)) {
+    return {
+      name: "tailwind.config",
+      severity: "warn",
+      message: "tailwind.config.js \uC874\uC7AC (TypeScript \uAD8C\uC7A5)"
+    };
+  }
+  return {
+    name: "tailwind.config",
+    severity: "fail",
+    message: "tailwind.config \uD30C\uC77C\uC774 \uC5C6\uC2B5\uB2C8\uB2E4"
+  };
+}
+async function checkGlobalsCss(baseDir) {
+  const candidates = [
+    "globals.css",
+    "app/globals.css",
+    "src/app/globals.css",
+    "src/globals.css",
+    "styles/globals.css"
+  ];
+  for (const candidate of candidates) {
+    const fullPath = path8.join(baseDir, candidate);
+    if (await fs8.pathExists(fullPath)) {
+      const content = await fs8.readFile(fullPath, "utf-8");
+      const hasTokens = content.includes("--background") && content.includes("--primary");
+      return {
+        name: "globals.css",
+        severity: hasTokens ? "pass" : "warn",
+        message: hasTokens ? `${candidate}\uC5D0 AXIS CSS \uBCC0\uC218\uAC00 \uC815\uC758\uB418\uC5B4 \uC788\uC2B5\uB2C8\uB2E4` : `${candidate}\uC5D0 AXIS CSS \uBCC0\uC218\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4`
+      };
+    }
+  }
+  return {
+    name: "globals.css",
+    severity: "fail",
+    message: "globals.css \uD30C\uC77C\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4"
+  };
+}
+async function checkUtils(baseDir) {
+  const candidates = [
+    "lib/utils.ts",
+    "src/lib/utils.ts",
+    "components/ui/utils.ts",
+    "src/components/ui/utils.ts",
+    "utils.ts"
+  ];
+  for (const candidate of candidates) {
+    const fullPath = path8.join(baseDir, candidate);
+    if (await fs8.pathExists(fullPath)) {
+      const content = await fs8.readFile(fullPath, "utf-8");
+      const hasCn = content.includes("function cn");
+      return {
+        name: "utils.ts",
+        severity: hasCn ? "pass" : "warn",
+        message: hasCn ? `${candidate}\uC5D0 cn() \uD568\uC218\uAC00 \uC788\uC2B5\uB2C8\uB2E4` : `${candidate}\uC5D0 cn() \uD568\uC218\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4`
+      };
+    }
+  }
+  return {
+    name: "utils.ts",
+    severity: "warn",
+    message: "utils.ts\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4 (\uCEF4\uD3EC\uB10C\uD2B8 \uC0AC\uC6A9 \uC2DC \uD544\uC694)"
+  };
+}
+async function checkDependencies(baseDir) {
+  const pkgPath = path8.join(baseDir, "package.json");
+  if (!await fs8.pathExists(pkgPath)) {
+    return {
+      name: "package.json",
+      severity: "fail",
+      message: "package.json \uD30C\uC77C\uC774 \uC5C6\uC2B5\uB2C8\uB2E4"
+    };
+  }
+  const pkg = await fs8.readJSON(pkgPath);
+  const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+  const required = ["tailwindcss"];
+  const recommended = ["clsx", "tailwind-merge"];
+  const missingRequired = required.filter((d) => !allDeps[d]);
+  const missingRecommended = recommended.filter((d) => !allDeps[d]);
+  if (missingRequired.length > 0) {
+    return {
+      name: "dependencies",
+      severity: "fail",
+      message: `\uD544\uC218 \uC758\uC874\uC131 \uB204\uB77D: ${missingRequired.join(", ")}`
+    };
+  }
+  if (missingRecommended.length > 0) {
+    return {
+      name: "dependencies",
+      severity: "warn",
+      message: `\uAD8C\uC7A5 \uC758\uC874\uC131 \uB204\uB77D: ${missingRecommended.join(", ")}`
+    };
+  }
+  return {
+    name: "dependencies",
+    severity: "pass",
+    message: "\uD544\uC218 \uBC0F \uAD8C\uC7A5 \uC758\uC874\uC131\uC774 \uBAA8\uB450 \uC124\uCE58\uB418\uC5B4 \uC788\uC2B5\uB2C8\uB2E4"
+  };
+}
+
+// src/template/index.ts
+function registerTemplateCommand(program2) {
+  const tplCmd = program2.command("template").alias("tpl").description("\uD504\uB85C\uC81D\uD2B8 \uD15C\uD50C\uB9BF \uAD00\uB9AC");
+  tplCmd.command("list").alias("ls").description("\uC0AC\uC6A9 \uAC00\uB2A5\uD55C \uD15C\uD50C\uB9BF \uBAA9\uB85D").option("--category <type>", "\uCE74\uD14C\uACE0\uB9AC \uD544\uD130").action(async (options) => {
+    const spinner = ora5("\uD15C\uD50C\uB9BF \uBAA9\uB85D \uAC00\uC838\uC624\uB294 \uC911...").start();
+    try {
+      const index = await fetchTemplateIndex();
+      spinner.stop();
+      let templates = index.templates;
+      if (options.category) {
+        templates = templates.filter((t) => t.category === options.category);
+      }
+      if (templates.length === 0) {
+        console.log(chalk7.yellow("\n\uC0AC\uC6A9 \uAC00\uB2A5\uD55C \uD15C\uD50C\uB9BF\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.\n"));
+        return;
+      }
+      console.log(chalk7.blue(`
+\u{1F4E6} AXIS \uD15C\uD50C\uB9BF (${templates.length}\uAC1C)
+`));
+      const byCategory = /* @__PURE__ */ new Map();
+      for (const t of templates) {
+        if (!byCategory.has(t.category)) {
+          byCategory.set(t.category, []);
+        }
+        byCategory.get(t.category).push(t);
+      }
+      for (const [category, items] of byCategory) {
+        console.log(chalk7.bold(`  ${category}`));
+        for (const t of items) {
+          console.log(
+            `    ${chalk7.cyan(t.slug.padEnd(20))} ${chalk7.gray(t.description.slice(0, 50))}`
+          );
+        }
+        console.log();
+      }
+      console.log(chalk7.gray("\uC0AC\uC6A9\uBC95: axis template info <name>"));
+      console.log(chalk7.gray("       axis template apply <name>\n"));
+    } catch (err) {
+      spinner.fail(err.message);
+      process.exit(1);
+    }
+  });
+  tplCmd.command("info <name>").description("\uD15C\uD50C\uB9BF \uC0C1\uC138 \uC815\uBCF4 \uBCF4\uAE30").action(async (name) => {
+    const spinner = ora5(`'${name}' \uC815\uBCF4 \uAC00\uC838\uC624\uB294 \uC911...`).start();
+    try {
+      const detail = await fetchTemplateDetail(name);
+      spinner.stop();
+      console.log(chalk7.blue(`
+\u{1F4CB} ${detail.name}
+`));
+      console.log(`  ${chalk7.bold("\uC124\uBA85")}: ${detail.description}`);
+      console.log(`  ${chalk7.bold("\uCE74\uD14C\uACE0\uB9AC")}: ${detail.category}`);
+      console.log(`  ${chalk7.bold("\uBC84\uC804")}: ${detail.version}`);
+      if (detail.tags.length > 0) {
+        console.log(`  ${chalk7.bold("\uD0DC\uADF8")}: ${detail.tags.join(", ")}`);
+      }
+      if (detail.features.length > 0) {
+        console.log(chalk7.bold("\n  \uAE30\uB2A5:"));
+        for (const f of detail.features) {
+          console.log(`    - ${f}`);
+        }
+      }
+      console.log(chalk7.bold(`
+  \uD30C\uC77C (${detail.files.length}\uAC1C):`));
+      for (const f of detail.files) {
+        console.log(`    ${chalk7.cyan(f.path)} ${chalk7.gray(`(${f.type})`)}`);
+      }
+      const deps = Object.keys(detail.dependencies || {});
+      const devDeps = Object.keys(detail.devDependencies || {});
+      if (deps.length > 0 || devDeps.length > 0) {
+        console.log(chalk7.bold("\n  \uC758\uC874\uC131:"));
+        if (deps.length > 0) {
+          console.log(`    dependencies: ${deps.join(", ")}`);
+        }
+        if (devDeps.length > 0) {
+          console.log(`    devDependencies: ${devDeps.join(", ")}`);
+        }
+      }
+      console.log(chalk7.gray(`
+\uC0AC\uC6A9\uBC95: axis template apply ${name}
+`));
+    } catch (err) {
+      spinner.fail(err.message);
+      process.exit(1);
+    }
+  });
+  tplCmd.command("apply <name>").description("\uD15C\uD50C\uB9BF\uC744 \uD604\uC7AC \uD504\uB85C\uC81D\uD2B8\uC5D0 \uC801\uC6A9").option("-y, --yes", "\uD655\uC778 \uC5C6\uC774 \uB36E\uC5B4\uC4F0\uAE30").option("--dry-run", "\uC2E4\uC81C \uD30C\uC77C \uC0DD\uC131 \uC5C6\uC774 \uBBF8\uB9AC\uBCF4\uAE30").option("--skip-deps", "\uC758\uC874\uC131 \uC548\uB0B4 \uC0DD\uB7B5").option("-d, --dir <path>", "\uB300\uC0C1 \uB514\uB809\uD1A0\uB9AC").action(async (name, options) => {
+    await applyTemplate(name, options);
+  });
+  tplCmd.command("init [name]").description("\uC0C8 \uD504\uB85C\uC81D\uD2B8\uB97C \uD15C\uD50C\uB9BF\uC73C\uB85C \uCD08\uAE30\uD654").option("-d, --dir <path>", "\uD504\uB85C\uC81D\uD2B8 \uB514\uB809\uD1A0\uB9AC").action(async (name, options) => {
+    await initTemplate(name, options);
+  });
+  tplCmd.command("diff <name>").description("\uB85C\uCEEC \uD504\uB85C\uC81D\uD2B8\uC640 \uD15C\uD50C\uB9BF\uC758 \uCC28\uC774 \uBE44\uAD50").option("--verbose", "\uB85C\uCEEC \uC804\uC6A9 \uD30C\uC77C\uB3C4 \uD45C\uC2DC").option("-d, --dir <path>", "\uB300\uC0C1 \uB514\uB809\uD1A0\uB9AC").action(async (name, options) => {
+    await diffTemplate(name, options);
+  });
+}
+function registerCheckCommand(program2) {
+  program2.command("check").description("AXIS \uD504\uB85C\uC81D\uD2B8 \uC124\uC815 \uAC80\uC99D").option("-d, --dir <path>", "\uB300\uC0C1 \uB514\uB809\uD1A0\uB9AC").action(async (options) => {
+    await runCheck(options.dir);
+  });
+}
+
+// src/index.ts
+var REGISTRY_URL = process.env.AXIS_REGISTRY_URL || "https://ds.minu.best/r";
+var program = new Command();
+program.name("axis").description("AXIS Design System CLI - shadcn \uD638\uD658 \uCEF4\uD3EC\uB10C\uD2B8 \uC124\uCE58 \uB3C4\uAD6C").version("0.1.0");
+program.command("init").description("\uD504\uB85C\uC81D\uD2B8\uC5D0 AXIS Design System \uCD08\uAE30\uD654").option("-y, --yes", "\uAE30\uBCF8\uAC12\uC73C\uB85C \uC790\uB3D9 \uC124\uC815").action(async (options) => {
+  console.log(chalk8.blue("\n\u{1F3A8} AXIS Design System \uCD08\uAE30\uD654\n"));
+  const config = options.yes ? {
+    componentsDir: "./src/components/ui",
+    tailwindConfig: "./tailwind.config.ts",
+    globalCss: "./src/app/globals.css"
+  } : await prompts2([
+    {
+      type: "text",
+      name: "componentsDir",
+      message: "\uCEF4\uD3EC\uB10C\uD2B8 \uB514\uB809\uD1A0\uB9AC:",
+      initial: "./src/components/ui"
+    },
+    {
+      type: "text",
+      name: "tailwindConfig",
+      message: "Tailwind \uC124\uC815 \uD30C\uC77C:",
+      initial: "./tailwind.config.ts"
+    },
+    {
+      type: "text",
+      name: "globalCss",
+      message: "\uAE00\uB85C\uBC8C CSS \uD30C\uC77C:",
+      initial: "./src/app/globals.css"
+    }
+  ]);
+  const axisConfig = {
+    $schema: "https://ds.minu.best/schema.json",
+    componentsDir: config.componentsDir,
+    tailwindConfig: config.tailwindConfig,
+    globalCss: config.globalCss,
+    registry: REGISTRY_URL
+  };
+  await fs9.writeJSON("axis.config.json", axisConfig, { spaces: 2 });
+  console.log(chalk8.green("\u2713 axis.config.json \uC0DD\uC131 \uC644\uB8CC"));
+  const utilsPath = path9.join(config.componentsDir, "utils.ts");
+  await fs9.ensureDir(path9.dirname(utilsPath));
+  await fs9.writeFile(
+    utilsPath,
+    `import { type ClassValue, clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs));
+}
+`
+  );
+  console.log(chalk8.green("\u2713 utils.ts \uC0DD\uC131 \uC644\uB8CC"));
+  console.log(chalk8.blue("\n\uCD08\uAE30\uD654 \uC644\uB8CC! \uC774\uC81C \uB2E4\uC74C \uBA85\uB839\uC5B4\uB85C \uCEF4\uD3EC\uB10C\uD2B8\uB97C \uCD94\uAC00\uD558\uC138\uC694:"));
+  console.log(chalk8.cyan("  npx axis-cli add button\n"));
+});
+program.command("add <component>").description("\uCEF4\uD3EC\uB10C\uD2B8 \uCD94\uAC00").option("--agentic", "Agentic UI \uCEF4\uD3EC\uB10C\uD2B8 \uCD94\uAC00").option("-y, --yes", "\uD655\uC778 \uC5C6\uC774 \uB36E\uC5B4\uC4F0\uAE30").action(async (component, options) => {
+  const spinner = ora6(`${component} \uCEF4\uD3EC\uB10C\uD2B8 \uAC00\uC838\uC624\uB294 \uC911...`).start();
+  try {
+    const configPath = path9.resolve("axis.config.json");
+    if (!await fs9.pathExists(configPath)) {
+      spinner.fail(
+        "axis.config.json\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.\n  \uD574\uACB0: \uD504\uB85C\uC81D\uD2B8 \uB8E8\uD2B8\uC5D0\uC11C 'npx @axis-ds/cli init'\uC744 \uC2E4\uD589\uD558\uC138\uC694.\n  \uCC38\uACE0: https://axis.minu.best/docs/guides/quick-start"
+      );
+      process.exit(1);
+    }
+    const config = await fs9.readJSON(configPath);
+    const category = options.agentic ? "agentic" : "ui";
+    const componentInfo = await getComponentInfo(component, category);
+    if (!componentInfo) {
+      spinner.fail(
+        `'${component}' \uCEF4\uD3EC\uB10C\uD2B8\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.
+  \uC0AC\uC6A9 \uAC00\uB2A5\uD55C \uCEF4\uD3EC\uB10C\uD2B8 \uBAA9\uB85D: npx @axis-ds/cli list
+  Agentic UI \uCEF4\uD3EC\uB10C\uD2B8\uB294 --agentic \uC635\uC158\uC744 \uCD94\uAC00\uD558\uC138\uC694.`
+      );
+      process.exit(1);
+    }
+    spinner.text = `${component} \uCEF4\uD3EC\uB10C\uD2B8 \uC124\uCE58 \uC911...`;
+    for (const file of componentInfo.files) {
+      const filePath = path9.join(config.componentsDir, file.path);
+      if (await fs9.pathExists(filePath)) {
+        if (!options.yes) {
+          const { overwrite } = await prompts2({
+            type: "confirm",
+            name: "overwrite",
+            message: `${file.path}\uC774(\uAC00) \uC774\uBBF8 \uC874\uC7AC\uD569\uB2C8\uB2E4. \uB36E\uC5B4\uC4F0\uC2DC\uACA0\uC2B5\uB2C8\uAE4C?`,
+            initial: false
+          });
+          if (!overwrite) continue;
+        }
+      }
+      await fs9.ensureDir(path9.dirname(filePath));
+      await fs9.writeFile(filePath, file.content);
+    }
+    spinner.succeed(chalk8.green(`${component} \uCEF4\uD3EC\uB10C\uD2B8 \uCD94\uAC00 \uC644\uB8CC`));
+    if (componentInfo.dependencies.length > 0) {
+      console.log(chalk8.yellow("\n\uD544\uC694\uD55C \uC758\uC874\uC131:"));
+      console.log(chalk8.cyan(`  pnpm add ${componentInfo.dependencies.join(" ")}`));
+    }
+  } catch (error) {
+    spinner.fail(
+      `\uCEF4\uD3EC\uB10C\uD2B8 \uCD94\uAC00 \uC911 \uC624\uB958 \uBC1C\uC0DD: ${error.message}
+  \uB124\uD2B8\uC6CC\uD06C \uBB38\uC81C\uC778 \uACBD\uC6B0 \uC778\uD130\uB137 \uC5F0\uACB0\uC744 \uD655\uC778\uD558\uC138\uC694.
+  \uBB38\uC81C\uAC00 \uC9C0\uC18D\uB418\uBA74 GitHub \uC774\uC288\uB97C \uC0DD\uC131\uD574 \uC8FC\uC138\uC694: https://github.com/IDEA-on-Action/AXIS-Design-System/issues`
+    );
+    process.exit(1);
+  }
+});
+program.command("list").description("\uC0AC\uC6A9 \uAC00\uB2A5\uD55C \uCEF4\uD3EC\uB10C\uD2B8 \uBAA9\uB85D").option("--category <type>", "\uCE74\uD14C\uACE0\uB9AC \uD544\uD130 (ui, agentic)").action(async (options) => {
+  console.log(chalk8.blue("\n\u{1F4E6} AXIS Design System \uCEF4\uD3EC\uB10C\uD2B8\n"));
+  const components = {
+    ui: [
+      { name: "button", description: "\uAE30\uBCF8 \uBC84\uD2BC \uCEF4\uD3EC\uB10C\uD2B8" },
+      { name: "input", description: "\uD14D\uC2A4\uD2B8 \uC785\uB825 \uD544\uB4DC" },
+      { name: "card", description: "\uCE74\uB4DC \uCEE8\uD14C\uC774\uB108" },
+      { name: "dialog", description: "\uBAA8\uB2EC \uB2E4\uC774\uC5BC\uB85C\uADF8" },
+      { name: "badge", description: "\uBC43\uC9C0/\uD0DC\uADF8" },
+      { name: "select", description: "\uC120\uD0DD \uB4DC\uB86D\uB2E4\uC6B4" },
+      { name: "tabs", description: "\uD0ED \uB124\uBE44\uAC8C\uC774\uC158" },
+      { name: "toast", description: "\uC54C\uB9BC \uD1A0\uC2A4\uD2B8" },
+      { name: "label", description: "\uD3FC \uB77C\uBCA8" },
+      { name: "separator", description: "\uAD6C\uBD84\uC120" }
+    ],
+    agentic: [
+      { name: "run-progress", description: "\uC5D0\uC774\uC804\uD2B8 \uC2E4\uD589 \uC9C4\uD589\uB960" },
+      { name: "step-timeline", description: "\uB2E8\uACC4\uBCC4 \uD0C0\uC784\uB77C\uC778" },
+      { name: "approval-card", description: "\uC0AC\uC6A9\uC790 \uC2B9\uC778 \uC694\uCCAD" },
+      { name: "streaming-text", description: "\uC2E4\uC2DC\uAC04 \uD14D\uC2A4\uD2B8 \uC2A4\uD2B8\uB9AC\uBC0D" },
+      { name: "tool-call-card", description: "\uB3C4\uAD6C \uD638\uCD9C \uD45C\uC2DC" },
+      { name: "source-panel", description: "AI \uADFC\uAC70/\uCD9C\uCC98 \uD45C\uC2DC" },
+      { name: "thinking-indicator", description: "\uC0DD\uAC01 \uC911 \uD45C\uC2DC" },
+      { name: "recovery-banner", description: "\uC624\uB958 \uBCF5\uAD6C \uC548\uB0B4" },
+      { name: "agent-avatar", description: "\uC5D0\uC774\uC804\uD2B8 \uC544\uBC14\uD0C0" },
+      { name: "surface-renderer", description: "\uB3D9\uC801 Surface \uB80C\uB354\uB9C1" }
+    ]
+  };
+  const showCategory = (category, items) => {
+    console.log(chalk8.bold(category === "ui" ? "Core UI" : "Agentic UI"));
+    items.forEach((c) => {
+      console.log(`  ${chalk8.cyan(c.name.padEnd(20))} ${chalk8.gray(c.description)}`);
+    });
+    console.log();
+  };
+  if (!options.category || options.category === "ui") {
+    showCategory("ui", components.ui);
+  }
+  if (!options.category || options.category === "agentic") {
+    showCategory("agentic", components.agentic);
+  }
+  console.log(chalk8.gray("\uC0AC\uC6A9\uBC95: npx axis-cli add <component-name>"));
+  console.log(chalk8.gray("Agentic: npx axis-cli add <component-name> --agentic\n"));
+});
+var monetCmd = program.command("monet").description("Monet Design \uCEF4\uD3EC\uB10C\uD2B8 \uAD00\uB9AC (https://monet.design)");
+monetCmd.command("list").alias("ls").description("Monet \uCE74\uD14C\uACE0\uB9AC \uBAA9\uB85D").action(async () => {
+  const client = new MonetClient();
+  await client.listCategories();
+});
+monetCmd.command("browse <category>").alias("b").description("\uCE74\uD14C\uACE0\uB9AC\uBCC4 \uCEF4\uD3EC\uB10C\uD2B8 \uBCF4\uAE30").action(async (category) => {
+  const client = new MonetClient();
+  await client.browseCategory(category);
+});
+monetCmd.command("search <query>").alias("s").description("\uCEF4\uD3EC\uB10C\uD2B8 \uAC80\uC0C9").action(async (query) => {
+  const client = new MonetClient();
+  await client.searchComponents(query);
+});
+monetCmd.command("import").alias("i").description("\uD074\uB9BD\uBCF4\uB4DC\uC5D0\uC11C \uCEF4\uD3EC\uB10C\uD2B8 \uAC00\uC838\uC624\uAE30").action(async () => {
+  const client = new MonetClient();
+  await client.importFromClipboard();
+});
+monetCmd.command("setup").description("Monet MCP \uC11C\uBC84 \uC124\uC815 \uC548\uB0B4").action(() => {
+  console.log(chalk8.blue("\n\u{1F527} Monet MCP \uC11C\uBC84 \uC124\uC815\n"));
+  console.log(chalk8.bold("1. API \uD0A4 \uBC1C\uAE09:"));
+  console.log(chalk8.cyan("   https://monet.design/mcp\n"));
+  console.log(chalk8.bold("2. \uD658\uACBD \uBCC0\uC218 \uC124\uC815:"));
+  console.log(chalk8.gray("   .env \uD30C\uC77C\uC5D0 \uCD94\uAC00:"));
+  console.log(chalk8.cyan("   MONET_API_KEY=your-api-key-here\n"));
+  console.log(chalk8.bold("3. Claude Code MCP \uC124\uC815:"));
+  console.log(chalk8.gray("   .claude/mcp.json\uC5D0\uC11C monet \uC11C\uBC84 \uD65C\uC131\uD654:\n"));
+  console.log(
+    chalk8.cyan(`   "monet": {
+     "url": "https://www.monet.design/api/remote/mcp",
+     "headers": { "Authorization": "Bearer \${MONET_API_KEY}" },
+     "disabled": false
+   }
+`)
+  );
+  console.log(chalk8.bold("4. Claude Code \uC7AC\uC2DC\uC791 \uD6C4 \uC0AC\uC6A9:"));
+  console.log(chalk8.gray('   "monet\uC5D0\uC11C hero \uCEF4\uD3EC\uB10C\uD2B8 \uCC3E\uC544\uC918"\n'));
+});
+var v0Cmd = program.command("v0").description("V0 (v0.app) \uCF54\uB4DC \uBCC0\uD658 \uBC0F \uD1B5\uD569");
+v0Cmd.command("convert <file>").alias("c").description("V0 \uCF54\uB4DC\uB97C AXIS \uC2A4\uD0C0\uC77C\uB85C \uBCC0\uD658").option("-o, --output <path>", "\uCD9C\uB825 \uD30C\uC77C \uACBD\uB85C").action(async (file, options) => {
+  const client = new V0Client();
+  await client.convertFile(file, options.output);
+});
+v0Cmd.command("import").alias("i").description("V0 URL/\uD074\uB9BD\uBCF4\uB4DC\uC5D0\uC11C \uAC00\uC838\uC624\uAE30").action(async () => {
+  const client = new V0Client();
+  await client.importFromUrl();
+});
+v0Cmd.command("guide").alias("g").description("V0 \u2192 AXIS \uBCC0\uD658 \uAC00\uC774\uB4DC").action(() => {
+  const client = new V0Client();
+  client.showGuide();
+});
+v0Cmd.command("setup").description("V0 GitHub \uC5F0\uB3D9 \uC548\uB0B4").action(async () => {
+  const client = new V0Client();
+  await client.setupGitHubSync();
+});
+var libraryCmd = program.command("library").alias("lib").description("\uB514\uC790\uC778 \uC2DC\uC2A4\uD15C \uB77C\uC774\uBE0C\uB7EC\uB9AC \uC218\uC9D1/\uBD84\uB958/\uBC30\uCE58");
+libraryCmd.command("collect").alias("c").description("\uC678\uBD80 \uC18C\uC2A4\uC5D0\uC11C \uCEF4\uD3EC\uB10C\uD2B8 \uC218\uC9D1").option("-s, --source <source>", "\uC18C\uC2A4 \uC9C0\uC815 (shadcn, monet, v0, axis)").option("-i, --incremental", "\uC99D\uBD84 \uC218\uC9D1 (\uBCC0\uACBD\uBD84\uB9CC)").option("--dry-run", "\uC2E4\uC81C \uC800\uC7A5 \uC5C6\uC774 \uBBF8\uB9AC\uBCF4\uAE30").action(async (options) => {
+  const curator = new LibraryCurator();
+  const sources = options.source ? [options.source] : void 0;
+  const results = await curator.collectAll(sources, {
+    incremental: options.incremental,
+    verbose: true
+  });
+  if (!options.dryRun) {
+    const index = await curator.generateIndex();
+    await curator.saveIndex(index);
+  }
+  let total = 0;
+  let failed = 0;
+  for (const [, result] of results) {
+    total += result.collected;
+    failed += result.failed;
+  }
+  console.log(chalk8.blue(`
+\u{1F4CA} \uC218\uC9D1 \uC644\uB8CC: ${total}\uAC1C \uCEF4\uD3EC\uB10C\uD2B8`));
+  if (failed > 0) {
+    console.log(chalk8.yellow(`   \uC2E4\uD328: ${failed}\uAC1C`));
+  }
+});
+libraryCmd.command("list").alias("ls").description("\uB77C\uC774\uBE0C\uB7EC\uB9AC \uCEF4\uD3EC\uB10C\uD2B8 \uBAA9\uB85D").option("-c, --category <category>", "\uCE74\uD14C\uACE0\uB9AC \uD544\uD130").option("-s, --source <source>", "\uC18C\uC2A4 \uD544\uD130").action(async (options) => {
+  const curator = new LibraryCurator();
+  const index = await curator.loadIndex();
+  if (!index) {
+    console.log(chalk8.yellow("\n\u26A0\uFE0F  \uB77C\uC774\uBE0C\uB7EC\uB9AC \uC778\uB371\uC2A4\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4."));
+    console.log(chalk8.gray("   \uD574\uACB0: npx @axis-ds/cli library collect \uBA85\uB839\uC5B4\uB85C \uC218\uC9D1\uC744 \uBA3C\uC800 \uC2E4\uD589\uD558\uC138\uC694.\n"));
+    return;
+  }
+  let components = index.components;
+  if (options.category) {
+    components = components.filter((c) => c.category === options.category);
+  }
+  if (options.source) {
+    components = components.filter((c) => c.source.type === options.source);
+  }
+  console.log(chalk8.blue(`
+\u{1F4E6} Library Components (${components.length}\uAC1C)
+`));
+  const byCategory = /* @__PURE__ */ new Map();
+  for (const comp of components) {
+    const cat = comp.category;
+    if (!byCategory.has(cat)) {
+      byCategory.set(cat, []);
+    }
+    byCategory.get(cat).push(comp);
+  }
+  for (const [category, items] of byCategory) {
+    console.log(chalk8.bold(`${category} (${items.length})`));
+    for (const item of items.slice(0, 10)) {
+      console.log(
+        `  ${chalk8.cyan(item.name.padEnd(25))} ${chalk8.gray(item.source.type.padEnd(8))} ${chalk8.gray(item.description.slice(0, 40))}`
+      );
+    }
+    if (items.length > 10) {
+      console.log(chalk8.gray(`  ... \uC678 ${items.length - 10}\uAC1C`));
+    }
+    console.log();
+  }
+});
+libraryCmd.command("search <query>").alias("s").description("\uCEF4\uD3EC\uB10C\uD2B8 \uAC80\uC0C9").option("-c, --category <category>", "\uCE74\uD14C\uACE0\uB9AC \uD544\uD130").option("-s, --source <source>", "\uC18C\uC2A4 \uD544\uD130").action(async (query, options) => {
+  const curator = new LibraryCurator();
+  const results = await curator.searchComponents(query, {
+    category: options.category,
+    source: options.source
+  });
+  if (results.length === 0) {
+    console.log(chalk8.yellow(`
+'${query}'\uC5D0 \uB300\uD55C \uAC80\uC0C9 \uACB0\uACFC\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4.
+`));
+    return;
+  }
+  console.log(chalk8.blue(`
+\u{1F50D} '${query}' \uAC80\uC0C9 \uACB0\uACFC (${results.length}\uAC1C)
+`));
+  for (const comp of results.slice(0, 20)) {
+    console.log(
+      `  ${chalk8.cyan(comp.name.padEnd(25))} ${chalk8.gray(comp.source.type.padEnd(8))} ${chalk8.gray(comp.category.padEnd(12))} ${chalk8.gray(comp.description.slice(0, 30))}`
+    );
+  }
+  if (results.length > 20) {
+    console.log(chalk8.gray(`
+  ... \uC678 ${results.length - 20}\uAC1C`));
+  }
+  console.log();
+});
+libraryCmd.command("stats").description("\uB77C\uC774\uBE0C\uB7EC\uB9AC \uD1B5\uACC4").action(async () => {
+  const curator = new LibraryCurator();
+  await curator.printStats();
+});
+libraryCmd.command("publish").description("\uC0AC\uC774\uD2B8\uC5D0 \uB77C\uC774\uBE0C\uB7EC\uB9AC \uBC30\uCE58").option("-o, --output <dir>", "\uCD9C\uB825 \uB514\uB809\uD1A0\uB9AC", "apps/web/public/library").option("--minify", "JSON \uC555\uCD95").option("--clean", "\uAE30\uC874 \uBC30\uCE58 \uC815\uB9AC \uD6C4 \uC7AC\uBC30\uCE58").action(async (options) => {
+  const curator = new LibraryCurator();
+  const publisher2 = new Publisher();
+  const index = await curator.loadIndex();
+  if (!index) {
+    console.log(chalk8.yellow("\n\u26A0\uFE0F  \uB77C\uC774\uBE0C\uB7EC\uB9AC \uC778\uB371\uC2A4\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4."));
+    console.log(chalk8.gray("   \uD574\uACB0: npx @axis-ds/cli library collect \uBA85\uB839\uC5B4\uB85C \uC218\uC9D1\uC744 \uBA3C\uC800 \uC2E4\uD589\uD558\uC138\uC694.\n"));
+    return;
+  }
+  console.log(chalk8.blue("\n\u{1F4E4} Library \uBC30\uCE58\n"));
+  console.log(chalk8.gray(`\uCD1D ${index.stats.total}\uAC1C \uCEF4\uD3EC\uB10C\uD2B8
+`));
+  if (options.clean) {
+    await publisher2.clean(options.output);
+  }
+  const result = await publisher2.publish(index, {
+    outputDir: options.output,
+    minify: options.minify,
+    generateSearchIndex: true
+  });
+  if (result.success) {
+    console.log(chalk8.green(`
+\u2713 \uBC30\uCE58 \uC644\uB8CC`));
+    console.log(chalk8.gray(`  - \uCD9C\uB825 \uB514\uB809\uD1A0\uB9AC: ${result.outputDir}`));
+    console.log(chalk8.gray(`  - \uC0DD\uC131\uB41C \uD30C\uC77C: ${result.files.length}\uAC1C`));
+    console.log(chalk8.gray(`  - \uCE74\uD14C\uACE0\uB9AC: ${result.stats.categoriesPublished}\uAC1C`));
+    console.log(chalk8.gray(`  - \uAC80\uC0C9 \uC778\uB371\uC2A4: ${result.stats.searchIndexSize}\uAC1C \uD56D\uBAA9`));
+  } else {
+    console.log(chalk8.red(`
+\u2717 \uBC30\uCE58 \uC2E4\uD328`));
+    for (const error of result.errors) {
+      console.log(chalk8.red(`  - ${error}`));
+    }
+  }
+  console.log();
+});
+registerSyncCommand(program);
+registerTemplateCommand(program);
+registerCheckCommand(program);
+async function getComponentInfo(name, category) {
+  const localComponents = {
+    button: {
+      name: "button",
+      type: "ui",
+      description: "Primary button component",
+      dependencies: ["@radix-ui/react-slot", "class-variance-authority", "clsx", "tailwind-merge"],
+      files: [
+        {
+          path: "button.tsx",
+          content: `import * as React from "react"
+import { Slot } from "@radix-ui/react-slot"
+import { cva, type VariantProps } from "class-variance-authority"
+import { cn } from "./utils"
+
+const buttonVariants = cva(
+  "inline-flex items-center justify-center whitespace-nowrap rounded-md text-sm font-medium transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50",
+  {
+    variants: {
+      variant: {
+        default: "bg-primary text-primary-foreground hover:bg-primary/90",
+        secondary: "bg-secondary text-secondary-foreground hover:bg-secondary/80",
+        ghost: "hover:bg-accent hover:text-accent-foreground",
+        destructive: "bg-destructive text-destructive-foreground hover:bg-destructive/90",
+        outline: "border border-input bg-background hover:bg-accent hover:text-accent-foreground",
+        link: "text-primary underline-offset-4 hover:underline",
+      },
+      size: {
+        sm: "h-8 px-3 text-xs",
+        default: "h-10 px-4 py-2",
+        lg: "h-12 px-6 text-base",
+        icon: "h-10 w-10",
+      },
+    },
+    defaultVariants: { variant: "default", size: "default" },
+  }
+)
+
+export interface ButtonProps
+  extends React.ButtonHTMLAttributes<HTMLButtonElement>,
+    VariantProps<typeof buttonVariants> {
+  asChild?: boolean
+}
+
+const Button = React.forwardRef<HTMLButtonElement, ButtonProps>(
+  ({ className, variant, size, asChild = false, ...props }, ref) => {
+    const Comp = asChild ? Slot : "button"
+    return <Comp className={cn(buttonVariants({ variant, size, className }))} ref={ref} {...props} />
+  }
+)
+Button.displayName = "Button"
+
+export { Button, buttonVariants }
+`
+        }
+      ]
+    }
+  };
+  return localComponents[name] || null;
+}
+program.parse();