@axis-ds/mcp 1.1.0

package/dist/index.js

@@ -0,0 +1,2996 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+
+// src/registry/loader.ts
+import { readFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+var DATA_DIR = join(__dirname, "data");
+var cachedRegistry = null;
+function loadComponents() {
+  const filePath = join(DATA_DIR, "components.json");
+  const content = readFileSync(filePath, "utf-8");
+  const data = JSON.parse(content);
+  return data.components;
+}
+function loadTokens() {
+  const filePath = join(DATA_DIR, "tokens.json");
+  const content = readFileSync(filePath, "utf-8");
+  const data = JSON.parse(content);
+  return data.tokens;
+}
+function getRegistry() {
+  if (!cachedRegistry) {
+    cachedRegistry = {
+      components: loadComponents(),
+      tokens: loadTokens()
+    };
+  }
+  return cachedRegistry;
+}
+function searchComponents(query, category) {
+  const registry = getRegistry();
+  const lowerQuery = query.toLowerCase();
+  return registry.components.filter((component) => {
+    if (category && component.category !== category) {
+      return false;
+    }
+    return component.name.toLowerCase().includes(lowerQuery) || component.displayName.toLowerCase().includes(lowerQuery) || component.description.toLowerCase().includes(lowerQuery);
+  });
+}
+function getComponent(name) {
+  const registry = getRegistry();
+  return registry.components.find(
+    (c) => c.name.toLowerCase() === name.toLowerCase()
+  );
+}
+function listComponents(category) {
+  const registry = getRegistry();
+  if (category) {
+    return registry.components.filter((c) => c.category === category);
+  }
+  return registry.components;
+}
+function listTokens(category) {
+  const registry = getRegistry();
+  if (category) {
+    return registry.tokens.filter((t) => t.category === category);
+  }
+  return registry.tokens;
+}
+function getToken(path4) {
+  const registry = getRegistry();
+  return registry.tokens.find(
+    (t) => t.path.toLowerCase() === path4.toLowerCase()
+  );
+}
+function getComponentStats() {
+  const registry = getRegistry();
+  const stats = {
+    core: 0,
+    agentic: 0,
+    form: 0,
+    layout: 0
+  };
+  for (const component of registry.components) {
+    stats[component.category]++;
+  }
+  return stats;
+}
+function getTokenStats() {
+  const registry = getRegistry();
+  const stats = {
+    color: 0,
+    typography: 0,
+    spacing: 0,
+    radius: 0,
+    shadow: 0,
+    animation: 0
+  };
+  for (const token of registry.tokens) {
+    stats[token.category]++;
+  }
+  return stats;
+}
+
+// src/tools/search.ts
+function handleSearchComponents(params) {
+  const { query, category } = params;
+  if (!query || query.trim() === "") {
+    throw new Error("\uAC80\uC0C9\uC5B4(query)\uB294 \uD544\uC218\uC785\uB2C8\uB2E4.");
+  }
+  const components = searchComponents(query, category);
+  return {
+    components,
+    totalCount: components.length,
+    query,
+    category
+  };
+}
+function formatSearchResult(result) {
+  const lines = [];
+  lines.push(`## \uAC80\uC0C9 \uACB0\uACFC: "${result.query}"`);
+  if (result.category) {
+    lines.push(`**\uCE74\uD14C\uACE0\uB9AC**: ${result.category}`);
+  }
+  lines.push(`**\uCD1D ${result.totalCount}\uAC1C \uCEF4\uD3EC\uB10C\uD2B8 \uBC1C\uACAC**`);
+  lines.push("");
+  if (result.components.length === 0) {
+    lines.push("\uAC80\uC0C9 \uACB0\uACFC\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4.");
+    return lines.join("\n");
+  }
+  for (const component of result.components) {
+    lines.push(`### ${component.displayName} (\`${component.name}\`)`);
+    lines.push(`- **\uC124\uBA85**: ${component.description}`);
+    lines.push(`- **\uCE74\uD14C\uACE0\uB9AC**: ${component.category}`);
+    lines.push(`- **\uD328\uD0A4\uC9C0**: ${component.package}`);
+    if (component.dependencies.length > 0) {
+      lines.push(`- **\uC758\uC874\uC131**: ${component.dependencies.join(", ")}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/tools/get.ts
+function handleGetComponent(params) {
+  const { name } = params;
+  if (!name || name.trim() === "") {
+    throw new Error("\uCEF4\uD3EC\uB10C\uD2B8 \uC774\uB984(name)\uC740 \uD544\uC218\uC785\uB2C8\uB2E4.");
+  }
+  const component = getComponent(name);
+  if (!component) {
+    return null;
+  }
+  return component;
+}
+function handleGetToken(params) {
+  const { path: path4 } = params;
+  if (!path4 || path4.trim() === "") {
+    throw new Error("\uD1A0\uD070 \uACBD\uB85C(path)\uB294 \uD544\uC218\uC785\uB2C8\uB2E4.");
+  }
+  const token = getToken(path4);
+  if (!token) {
+    return null;
+  }
+  return token;
+}
+function formatComponentDetail(component) {
+  if (!component) {
+    return "\uCEF4\uD3EC\uB10C\uD2B8\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.";
+  }
+  const lines = [];
+  lines.push(`# ${component.displayName}`);
+  lines.push("");
+  lines.push(`> ${component.description}`);
+  lines.push("");
+  lines.push("## \uAE30\uBCF8 \uC815\uBCF4");
+  lines.push(`- **\uC774\uB984**: \`${component.name}\``);
+  lines.push(`- **\uCE74\uD14C\uACE0\uB9AC**: ${component.category}`);
+  lines.push(`- **\uD328\uD0A4\uC9C0**: \`${component.package}\``);
+  lines.push("");
+  if (component.dependencies.length > 0) {
+    lines.push("## \uC758\uC874\uC131");
+    lines.push("```bash");
+    lines.push(`npm install ${component.dependencies.join(" ")}`);
+    lines.push("```");
+    lines.push("");
+  }
+  if (component.files.length > 0) {
+    lines.push("## \uD30C\uC77C \uAD6C\uC870");
+    for (const file of component.files) {
+      lines.push(`- \`${file.path}\` (${file.type})`);
+    }
+    lines.push("");
+  }
+  if (component.props && component.props.length > 0) {
+    lines.push("## Props");
+    lines.push("| \uC774\uB984 | \uD0C0\uC785 | \uD544\uC218 | \uAE30\uBCF8\uAC12 | \uC124\uBA85 |");
+    lines.push("|------|------|------|--------|------|");
+    for (const prop of component.props) {
+      const required = prop.required ? "\u2713" : "";
+      const defaultVal = prop.default || "-";
+      lines.push(
+        `| \`${prop.name}\` | \`${prop.type}\` | ${required} | ${defaultVal} | ${prop.description} |`
+      );
+    }
+    lines.push("");
+  }
+  if (component.examples && component.examples.length > 0) {
+    lines.push("## \uC608\uC81C");
+    for (const example of component.examples) {
+      lines.push(`### ${example.title}`);
+      if (example.description) {
+        lines.push(example.description);
+      }
+      lines.push("```tsx");
+      lines.push(example.code);
+      lines.push("```");
+      lines.push("");
+    }
+  }
+  return lines.join("\n");
+}
+function formatTokenDetail(token) {
+  if (!token) {
+    return "\uD1A0\uD070\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.";
+  }
+  const lines = [];
+  lines.push(`# \uD1A0\uD070: ${token.path}`);
+  lines.push("");
+  lines.push(`- **\uAC12**: \`${token.value}\``);
+  lines.push(`- **\uCE74\uD14C\uACE0\uB9AC**: ${token.category}`);
+  if (token.description) {
+    lines.push(`- **\uC124\uBA85**: ${token.description}`);
+  }
+  if (token.cssVariable) {
+    lines.push(`- **CSS \uBCC0\uC218**: \`var(${token.cssVariable})\``);
+  }
+  return lines.join("\n");
+}
+
+// src/tools/list.ts
+function handleListComponents(params) {
+  const { category } = params;
+  const components = listComponents(category);
+  const stats = getComponentStats();
+  return {
+    components,
+    totalCount: components.length,
+    stats,
+    category
+  };
+}
+function handleListTokens(params) {
+  const { category } = params;
+  const tokens = listTokens(category);
+  const stats = getTokenStats();
+  return {
+    tokens,
+    totalCount: tokens.length,
+    stats,
+    category
+  };
+}
+function formatComponentList(result) {
+  const lines = [];
+  lines.push("# AXIS Design System \uCEF4\uD3EC\uB10C\uD2B8 \uBAA9\uB85D");
+  lines.push("");
+  lines.push("## \uCE74\uD14C\uACE0\uB9AC\uBCC4 \uD1B5\uACC4");
+  lines.push("| \uCE74\uD14C\uACE0\uB9AC | \uAC1C\uC218 |");
+  lines.push("|----------|------|");
+  lines.push(`| Core | ${result.stats.core} |`);
+  lines.push(`| Form | ${result.stats.form} |`);
+  lines.push(`| Layout | ${result.stats.layout} |`);
+  lines.push(`| Agentic | ${result.stats.agentic} |`);
+  lines.push(`| **\uD569\uACC4** | **${result.totalCount}** |`);
+  lines.push("");
+  if (result.category) {
+    lines.push(`## ${result.category} \uCE74\uD14C\uACE0\uB9AC \uCEF4\uD3EC\uB10C\uD2B8`);
+  } else {
+    lines.push("## \uC804\uCCB4 \uCEF4\uD3EC\uB10C\uD2B8");
+  }
+  lines.push("");
+  const grouped = {};
+  for (const component of result.components) {
+    if (!grouped[component.category]) {
+      grouped[component.category] = [];
+    }
+    grouped[component.category].push(component);
+  }
+  for (const [category, components] of Object.entries(grouped)) {
+    lines.push(`### ${category.charAt(0).toUpperCase() + category.slice(1)}`);
+    lines.push("| \uC774\uB984 | \uC124\uBA85 | \uD328\uD0A4\uC9C0 |");
+    lines.push("|------|------|--------|");
+    for (const c of components) {
+      lines.push(`| \`${c.name}\` | ${c.description} | ${c.package} |`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function formatTokenList(result) {
+  const lines = [];
+  lines.push("# AXIS Design System \uD1A0\uD070 \uBAA9\uB85D");
+  lines.push("");
+  lines.push("## \uCE74\uD14C\uACE0\uB9AC\uBCC4 \uD1B5\uACC4");
+  lines.push("| \uCE74\uD14C\uACE0\uB9AC | \uAC1C\uC218 |");
+  lines.push("|----------|------|");
+  lines.push(`| Color | ${result.stats.color} |`);
+  lines.push(`| Typography | ${result.stats.typography} |`);
+  lines.push(`| Spacing | ${result.stats.spacing} |`);
+  lines.push(`| Radius | ${result.stats.radius} |`);
+  lines.push(`| Shadow | ${result.stats.shadow} |`);
+  lines.push(`| Animation | ${result.stats.animation} |`);
+  lines.push(`| **\uD569\uACC4** | **${result.totalCount}** |`);
+  lines.push("");
+  if (result.category) {
+    lines.push(`## ${result.category} \uD1A0\uD070`);
+  } else {
+    lines.push("## \uC804\uCCB4 \uD1A0\uD070");
+  }
+  lines.push("");
+  const grouped = {};
+  for (const token of result.tokens) {
+    if (!grouped[token.category]) {
+      grouped[token.category] = [];
+    }
+    grouped[token.category].push(token);
+  }
+  for (const [category, tokens] of Object.entries(grouped)) {
+    lines.push(`### ${category.charAt(0).toUpperCase() + category.slice(1)}`);
+    lines.push("| \uACBD\uB85C | \uAC12 | \uC124\uBA85 |");
+    lines.push("|------|-----|------|");
+    for (const t of tokens) {
+      const desc = t.description || "-";
+      lines.push(`| \`${t.path}\` | \`${t.value}\` | ${desc} |`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/tools/install.ts
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { join as join2, dirname as dirname2 } from "path";
+var COMPONENT_TEMPLATES = {
+  button: {
+    "components/ui/button.tsx": `import * as React from "react"
+import { Slot } from "@radix-ui/react-slot"
+import { cva, type VariantProps } from "class-variance-authority"
+
+import { cn } from "@/lib/utils"
+
+const buttonVariants = cva(
+  "inline-flex items-center justify-center gap-2 whitespace-nowrap rounded-md text-sm font-medium transition-colors focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring disabled:pointer-events-none disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:size-4 [&_svg]:shrink-0",
+  {
+    variants: {
+      variant: {
+        default:
+          "bg-primary text-primary-foreground shadow hover:bg-primary/90",
+        destructive:
+          "bg-destructive text-destructive-foreground shadow-sm hover:bg-destructive/90",
+        outline:
+          "border border-input bg-background shadow-sm hover:bg-accent hover:text-accent-foreground",
+        secondary:
+          "bg-secondary text-secondary-foreground shadow-sm hover:bg-secondary/80",
+        ghost: "hover:bg-accent hover:text-accent-foreground",
+        link: "text-primary underline-offset-4 hover:underline",
+      },
+      size: {
+        default: "h-9 px-4 py-2",
+        sm: "h-8 rounded-md px-3 text-xs",
+        lg: "h-10 rounded-md px-8",
+        icon: "h-9 w-9",
+      },
+    },
+    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 }
+`
+  },
+  input: {
+    "components/ui/input.tsx": `import * as React from "react"
+
+import { cn } from "@/lib/utils"
+
+const Input = React.forwardRef<HTMLInputElement, React.ComponentProps<"input">>(
+  ({ className, type, ...props }, ref) => {
+    return (
+      <input
+        type={type}
+        className={cn(
+          "flex h-9 w-full rounded-md border border-input bg-transparent px-3 py-1 text-base shadow-sm transition-colors file:border-0 file:bg-transparent file:text-sm file:font-medium file:text-foreground placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring disabled:cursor-not-allowed disabled:opacity-50 md:text-sm",
+          className
+        )}
+        ref={ref}
+        {...props}
+      />
+    )
+  }
+)
+Input.displayName = "Input"
+
+export { Input }
+`
+  },
+  label: {
+    "components/ui/label.tsx": `"use client"
+
+import * as React from "react"
+import * as LabelPrimitive from "@radix-ui/react-label"
+import { cva, type VariantProps } from "class-variance-authority"
+
+import { cn } from "@/lib/utils"
+
+const labelVariants = cva(
+  "text-sm font-medium leading-none peer-disabled:cursor-not-allowed peer-disabled:opacity-70"
+)
+
+const Label = React.forwardRef<
+  React.ElementRef<typeof LabelPrimitive.Root>,
+  React.ComponentPropsWithoutRef<typeof LabelPrimitive.Root> &
+    VariantProps<typeof labelVariants>
+>(({ className, ...props }, ref) => (
+  <LabelPrimitive.Root
+    ref={ref}
+    className={cn(labelVariants(), className)}
+    {...props}
+  />
+))
+Label.displayName = LabelPrimitive.Root.displayName
+
+export { Label }
+`
+  },
+  card: {
+    "components/ui/card.tsx": `import * as React from "react"
+
+import { cn } from "@/lib/utils"
+
+const Card = React.forwardRef<
+  HTMLDivElement,
+  React.HTMLAttributes<HTMLDivElement>
+>(({ className, ...props }, ref) => (
+  <div
+    ref={ref}
+    className={cn(
+      "rounded-xl border bg-card text-card-foreground shadow",
+      className
+    )}
+    {...props}
+  />
+))
+Card.displayName = "Card"
+
+const CardHeader = React.forwardRef<
+  HTMLDivElement,
+  React.HTMLAttributes<HTMLDivElement>
+>(({ className, ...props }, ref) => (
+  <div
+    ref={ref}
+    className={cn("flex flex-col space-y-1.5 p-6", className)}
+    {...props}
+  />
+))
+CardHeader.displayName = "CardHeader"
+
+const CardTitle = React.forwardRef<
+  HTMLDivElement,
+  React.HTMLAttributes<HTMLDivElement>
+>(({ className, ...props }, ref) => (
+  <div
+    ref={ref}
+    className={cn("font-semibold leading-none tracking-tight", className)}
+    {...props}
+  />
+))
+CardTitle.displayName = "CardTitle"
+
+const CardDescription = React.forwardRef<
+  HTMLDivElement,
+  React.HTMLAttributes<HTMLDivElement>
+>(({ className, ...props }, ref) => (
+  <div
+    ref={ref}
+    className={cn("text-sm text-muted-foreground", className)}
+    {...props}
+  />
+))
+CardDescription.displayName = "CardDescription"
+
+const CardContent = React.forwardRef<
+  HTMLDivElement,
+  React.HTMLAttributes<HTMLDivElement>
+>(({ className, ...props }, ref) => (
+  <div ref={ref} className={cn("p-6 pt-0", className)} {...props} />
+))
+CardContent.displayName = "CardContent"
+
+const CardFooter = React.forwardRef<
+  HTMLDivElement,
+  React.HTMLAttributes<HTMLDivElement>
+>(({ className, ...props }, ref) => (
+  <div
+    ref={ref}
+    className={cn("flex items-center p-6 pt-0", className)}
+    {...props}
+  />
+))
+CardFooter.displayName = "CardFooter"
+
+export { Card, CardHeader, CardFooter, CardTitle, CardDescription, CardContent }
+`
+  },
+  badge: {
+    "components/ui/badge.tsx": `import * as React from "react"
+import { cva, type VariantProps } from "class-variance-authority"
+
+import { cn } from "@/lib/utils"
+
+const badgeVariants = cva(
+  "inline-flex items-center rounded-md border px-2.5 py-0.5 text-xs font-semibold transition-colors focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2",
+  {
+    variants: {
+      variant: {
+        default:
+          "border-transparent bg-primary text-primary-foreground shadow hover:bg-primary/80",
+        secondary:
+          "border-transparent bg-secondary text-secondary-foreground hover:bg-secondary/80",
+        destructive:
+          "border-transparent bg-destructive text-destructive-foreground shadow hover:bg-destructive/80",
+        outline: "text-foreground",
+      },
+    },
+    defaultVariants: {
+      variant: "default",
+    },
+  }
+)
+
+export interface BadgeProps
+  extends React.HTMLAttributes<HTMLDivElement>,
+    VariantProps<typeof badgeVariants> {}
+
+function Badge({ className, variant, ...props }: BadgeProps) {
+  return (
+    <div className={cn(badgeVariants({ variant }), className)} {...props} />
+  )
+}
+
+export { Badge, badgeVariants }
+`
+  }
+};
+function handleInstallComponent(params) {
+  const { name, targetDir } = params;
+  if (!name || name.trim() === "") {
+    throw new Error("\uCEF4\uD3EC\uB10C\uD2B8 \uC774\uB984(name)\uC740 \uD544\uC218\uC785\uB2C8\uB2E4.");
+  }
+  if (!targetDir || targetDir.trim() === "") {
+    throw new Error("\uB300\uC0C1 \uB514\uB809\uD1A0\uB9AC(targetDir)\uB294 \uD544\uC218\uC785\uB2C8\uB2E4.");
+  }
+  const component = getComponent(name);
+  if (!component) {
+    return {
+      success: false,
+      installedFiles: [],
+      dependencies: [],
+      message: `\uCEF4\uD3EC\uB10C\uD2B8 '${name}'\uC744(\uB97C) \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.`
+    };
+  }
+  const templates = COMPONENT_TEMPLATES[name.toLowerCase()];
+  if (!templates) {
+    return {
+      success: false,
+      installedFiles: [],
+      dependencies: component.dependencies,
+      message: `\uCEF4\uD3EC\uB10C\uD2B8 '${name}'\uC758 \uD15C\uD50C\uB9BF\uC774 \uC544\uC9C1 \uC900\uBE44\uB418\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4. \uC218\uB3D9\uC73C\uB85C \uC124\uCE58\uD574 \uC8FC\uC138\uC694.`
+    };
+  }
+  const installedFiles = [];
+  try {
+    for (const [relativePath, content] of Object.entries(templates)) {
+      const fullPath = join2(targetDir, relativePath);
+      const dir = dirname2(fullPath);
+      if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+      }
+      writeFileSync(fullPath, content, "utf-8");
+      installedFiles.push(relativePath);
+    }
+    return {
+      success: true,
+      installedFiles,
+      dependencies: component.dependencies,
+      message: `\uCEF4\uD3EC\uB10C\uD2B8 '${name}'\uC774(\uAC00) \uC131\uACF5\uC801\uC73C\uB85C \uC124\uCE58\uB418\uC5C8\uC2B5\uB2C8\uB2E4.`
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "\uC54C \uC218 \uC5C6\uB294 \uC624\uB958";
+    return {
+      success: false,
+      installedFiles,
+      dependencies: component.dependencies,
+      message: `\uC124\uCE58 \uC911 \uC624\uB958 \uBC1C\uC0DD: ${errorMessage}`
+    };
+  }
+}
+function formatInstallResult(result) {
+  const lines = [];
+  if (result.success) {
+    lines.push("# \uCEF4\uD3EC\uB10C\uD2B8 \uC124\uCE58 \uC644\uB8CC");
+    lines.push("");
+    lines.push(result.message);
+    lines.push("");
+    if (result.installedFiles.length > 0) {
+      lines.push("## \uC124\uCE58\uB41C \uD30C\uC77C");
+      for (const file of result.installedFiles) {
+        lines.push(`- \`${file}\``);
+      }
+      lines.push("");
+    }
+    if (result.dependencies.length > 0) {
+      lines.push("## \uD544\uC694\uD55C \uC758\uC874\uC131");
+      lines.push("\uB2E4\uC74C \uD328\uD0A4\uC9C0\uB97C \uC124\uCE58\uD574 \uC8FC\uC138\uC694:");
+      lines.push("");
+      lines.push("```bash");
+      lines.push(`npm install ${result.dependencies.join(" ")}`);
+      lines.push("```");
+    }
+  } else {
+    lines.push("# \uCEF4\uD3EC\uB10C\uD2B8 \uC124\uCE58 \uC2E4\uD328");
+    lines.push("");
+    lines.push(result.message);
+    if (result.dependencies.length > 0) {
+      lines.push("");
+      lines.push("## \uD544\uC694\uD55C \uC758\uC874\uC131 (\uCC38\uACE0)");
+      for (const dep of result.dependencies) {
+        lines.push(`- \`${dep}\``);
+      }
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/tools/prompt/detect.ts
+var DEFAULT_MIN_SCORE = 70;
+var DEFAULT_MAX_CANDIDATES = 5;
+var REUSABLE_PATTERNS = {
+  goal: ["\uBAA9\uD45C", "\uBAA9\uC801", "\uB2EC\uC131", "\uC704\uD574", "\uC218\uD589"],
+  steps: ["\uB2E8\uACC4", "\uC808\uCC28", "\uC21C\uC11C", "\uBA3C\uC800", "\uB2E4\uC74C", "\uB9C8\uC9C0\uB9C9"],
+  output: ["\uCD9C\uB825", "\uACB0\uACFC", "\uD615\uC2DD", "\uD15C\uD50C\uB9BF", "\uC0B0\uCD9C\uBB3C"],
+  validation: ["\uAC80\uC99D", "\uD655\uC778", "\uCCB4\uD06C", "\uD14C\uC2A4\uD2B8", "\uAC80\uC0AC"],
+  planning: ["\uACC4\uD68D", "\uC124\uACC4", "\uC804\uB7B5", "\uB85C\uB4DC\uB9F5", "\uB9C8\uC77C\uC2A4\uD1A4"],
+  quality: ["\uB9AC\uBDF0", "\uC810\uAC80", "\uBD84\uC11D", "\uD3C9\uAC00", "\uD488\uC9C8"],
+  documentation: ["\uBB38\uC11C", "\uAC00\uC774\uB4DC", "\uC124\uBA85", "\uB9E4\uB274\uC5BC", "README"],
+  workflow: ["\uC6CC\uD06C\uD50C\uB85C\uC6B0", "\uD504\uB85C\uC138\uC2A4", "\uD30C\uC774\uD504\uB77C\uC778", "\uC790\uB3D9\uD654"]
+};
+var PROJECT_SPECIFIC_PATTERNS = [
+  // 파일 경로
+  /(?:src|packages|apps|lib|components)\/[\w\-\/]+\.(?:ts|tsx|js|jsx|md)/gi,
+  // 컴포넌트명 (PascalCase)
+  /\b[A-Z][a-z]+(?:[A-Z][a-z]+)+\b/g,
+  // 버전
+  /\b\d+\.\d+\.\d+(?:-[\w.]+)?\b/g,
+  // 날짜
+  /\b\d{4}-\d{2}-\d{2}\b/g,
+  // 패키지명
+  /@[\w-]+\/[\w-]+/g
+];
+function segmentText(text) {
+  const sections = text.split(/(?=^#{1,3}\s)/m);
+  return sections.filter((s) => s.trim().length > 50);
+}
+function calculateRepeatability(text, _context) {
+  let score = 0;
+  const structuredPatterns = [
+    REUSABLE_PATTERNS.goal,
+    REUSABLE_PATTERNS.steps,
+    REUSABLE_PATTERNS.output
+  ];
+  for (const patterns of structuredPatterns) {
+    if (patterns.some((p) => text.includes(p))) {
+      score += 5;
+    }
+  }
+  if (/^#{1,3}\s/m.test(text)) score += 5;
+  if (/^[\-\*]\s/m.test(text)) score += 3;
+  if (/^\d+\.\s/m.test(text)) score += 2;
+  return Math.min(25, score);
+}
+function calculateGenerality(text) {
+  let score = 30;
+  for (const pattern of PROJECT_SPECIFIC_PATTERNS) {
+    const matches = text.match(pattern);
+    if (matches) {
+      score -= Math.min(10, matches.length * 2);
+    }
+  }
+  return Math.max(0, score);
+}
+function calculateIndependence(text) {
+  let score = 25;
+  const contextDependentPhrases = [
+    "\uC704\uC5D0\uC11C \uC5B8\uAE09\uD55C",
+    "\uC55E\uC11C \uB9D0\uD55C",
+    "\uC774\uC804\uC5D0",
+    "\uC544\uAE4C",
+    "\uC704 \uCF54\uB4DC",
+    "\uC544\uB798 \uCF54\uB4DC"
+  ];
+  for (const phrase of contextDependentPhrases) {
+    if (text.includes(phrase)) {
+      score -= 5;
+    }
+  }
+  return Math.max(0, score);
+}
+function calculateClarity(text) {
+  let score = 0;
+  if (REUSABLE_PATTERNS.goal.some(
+    (p) => text.includes(`## ${p}`) || text.includes(`### ${p}`)
+  )) {
+    score += 5;
+  }
+  if (REUSABLE_PATTERNS.steps.some(
+    (p) => text.includes(`## ${p}`) || text.includes(`### ${p}`)
+  )) {
+    score += 5;
+  }
+  if (text.includes("```") && text.includes("\uCD9C\uB825")) {
+    score += 5;
+  }
+  if (/\[[\sx]\]/i.test(text)) {
+    score += 5;
+  }
+  return Math.min(20, score);
+}
+function calculateScores(text, context) {
+  const repeatability = calculateRepeatability(text, context);
+  const generality = calculateGenerality(text);
+  const independence = calculateIndependence(text);
+  const clarity = calculateClarity(text);
+  return {
+    repeatability,
+    generality,
+    independence,
+    clarity,
+    total: repeatability + generality + independence + clarity
+  };
+}
+function suggestCategory(text) {
+  const categoryScores = {
+    planning: 0,
+    quality: 0,
+    documentation: 0,
+    workflow: 0
+  };
+  for (const keyword of REUSABLE_PATTERNS.planning) {
+    if (text.includes(keyword)) categoryScores.planning += 1;
+  }
+  for (const keyword of REUSABLE_PATTERNS.quality) {
+    if (text.includes(keyword)) categoryScores.quality += 1;
+  }
+  for (const keyword of REUSABLE_PATTERNS.documentation) {
+    if (text.includes(keyword)) categoryScores.documentation += 1;
+  }
+  for (const keyword of REUSABLE_PATTERNS.workflow) {
+    if (text.includes(keyword)) categoryScores.workflow += 1;
+  }
+  const entries = Object.entries(categoryScores);
+  entries.sort((a, b) => b[1] - a[1]);
+  return entries[0][0];
+}
+function extractVariables(text) {
+  const variables = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const pattern of PROJECT_SPECIFIC_PATTERNS) {
+    const matches = text.match(pattern);
+    if (matches) {
+      for (const match of matches) {
+        if (seen.has(match)) continue;
+        seen.add(match);
+        let varName;
+        let description;
+        if (match.includes("/")) {
+          varName = "{{FILE_PATH}}";
+          description = "\uD30C\uC77C \uACBD\uB85C";
+        } else if (/^\d+\.\d+\.\d+/.test(match)) {
+          varName = "{{VERSION}}";
+          description = "\uBC84\uC804";
+        } else if (/^\d{4}-\d{2}-\d{2}$/.test(match)) {
+          varName = "{{DATE}}";
+          description = "\uB0A0\uC9DC";
+        } else if (match.startsWith("@")) {
+          varName = "{{PACKAGE_NAME}}";
+          description = "\uD328\uD0A4\uC9C0\uBA85";
+        } else {
+          varName = "{{COMPONENT_NAME}}";
+          description = "\uCEF4\uD3EC\uB10C\uD2B8/\uAE30\uB2A5\uBA85";
+        }
+        if (!variables.some((v) => v.name === varName)) {
+          variables.push({
+            name: varName,
+            description,
+            originalValue: match
+          });
+        }
+      }
+    }
+  }
+  return variables;
+}
+function generateSuggestions(scores) {
+  const suggestions = [];
+  if (scores.repeatability < 15) {
+    suggestions.push("\uAD6C\uC870\uD654\uB41C \uC139\uC158 (\uBAA9\uD45C, \uB2E8\uACC4, \uCD9C\uB825) \uCD94\uAC00 \uAD8C\uC7A5");
+  }
+  if (scores.generality < 20) {
+    suggestions.push("\uD504\uB85C\uC81D\uD2B8 \uD2B9\uC815 \uAC12\uC744 \uBCC0\uC218\uB85C \uB300\uCCB4 \uD544\uC694");
+  }
+  if (scores.independence < 15) {
+    suggestions.push("\uCEE8\uD14D\uC2A4\uD2B8 \uC758\uC874 \uD45C\uD604 \uC81C\uAC70 \uD544\uC694");
+  }
+  if (scores.clarity < 12) {
+    suggestions.push("\uCD9C\uB825 \uD615\uC2DD \uBC0F \uAC80\uC99D \uCCB4\uD06C\uB9AC\uC2A4\uD2B8 \uCD94\uAC00 \uAD8C\uC7A5");
+  }
+  return suggestions;
+}
+function handleDetect(params) {
+  const {
+    context,
+    minScore = DEFAULT_MIN_SCORE,
+    maxCandidates = DEFAULT_MAX_CANDIDATES
+  } = params;
+  if (!context || context.trim() === "") {
+    throw new Error("\uCEE8\uD14D\uC2A4\uD2B8(context)\uB294 \uD544\uC218\uC785\uB2C8\uB2E4.");
+  }
+  const segments = segmentText(context);
+  const candidates = [];
+  for (let i = 0; i < segments.length; i++) {
+    const segment = segments[i];
+    const scores = calculateScores(segment, context);
+    if (scores.total >= minScore) {
+      candidates.push({
+        id: `candidate-${i + 1}`,
+        source: i === 0 ? "user_input" : "work_output",
+        originalText: segment,
+        scores,
+        suggestedCategory: suggestCategory(segment),
+        extractedVariables: extractVariables(segment),
+        suggestions: generateSuggestions(scores)
+      });
+    }
+  }
+  candidates.sort((a, b) => b.scores.total - a.scores.total);
+  const limitedCandidates = candidates.slice(0, maxCandidates);
+  return {
+    candidates: limitedCandidates,
+    totalFound: candidates.length,
+    threshold: minScore
+  };
+}
+function formatDetectResult(result) {
+  const lines = [];
+  lines.push("## \uD504\uB86C\uD504\uD2B8 \uD6C4\uBCF4 \uD0D0\uC9C0");
+  lines.push("");
+  lines.push(`**\uCD5C\uC18C \uC810\uC218 \uAE30\uC900**: ${result.threshold}\uC810`);
+  lines.push(`**\uBC1C\uACAC\uB41C \uD6C4\uBCF4**: ${result.totalFound}\uAC1C`);
+  lines.push("");
+  if (result.candidates.length === 0) {
+    lines.push("\uC7AC\uC0AC\uC6A9 \uAC00\uB2A5\uD55C \uD504\uB86C\uD504\uD2B8 \uD6C4\uBCF4\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4.");
+    return lines.join("\n");
+  }
+  lines.push(
+    "| # | \uC18C\uC2A4 | \uC810\uC218 | \uCE74\uD14C\uACE0\uB9AC (\uCD94\uCC9C) | \uBCC0\uC218 \uC218 |"
+  );
+  lines.push("|---|------|------|-----------------|---------|");
+  for (let i = 0; i < result.candidates.length; i++) {
+    const c = result.candidates[i];
+    const sourceLabel = c.source === "user_input" ? "\uC0AC\uC6A9\uC790 \uC785\uB825" : c.source === "work_output" ? "\uC791\uC5C5 \uACB0\uACFC\uBB3C" : "\uCEE8\uD14D\uC2A4\uD2B8";
+    lines.push(
+      `| ${i + 1} | ${sourceLabel} | ${c.scores.total}\uC810 | ${c.suggestedCategory} | ${c.extractedVariables.length}\uAC1C |`
+    );
+  }
+  lines.push("");
+  lines.push("### \uC0C1\uC138 \uC815\uBCF4");
+  lines.push("");
+  for (let i = 0; i < result.candidates.length; i++) {
+    const c = result.candidates[i];
+    lines.push(`#### \uD6C4\uBCF4 ${i + 1}`);
+    lines.push("");
+    lines.push("**\uC810\uC218 \uC0C1\uC138**:");
+    lines.push(`- \uBC18\uBCF5\uC131: ${c.scores.repeatability}/25`);
+    lines.push(`- \uBC94\uC6A9\uC131: ${c.scores.generality}/30`);
+    lines.push(`- \uB3C5\uB9BD\uC131: ${c.scores.independence}/25`);
+    lines.push(`- \uBA85\uD655\uC131: ${c.scores.clarity}/20`);
+    lines.push("");
+    if (c.extractedVariables.length > 0) {
+      lines.push("**\uCD94\uCD9C\uB41C \uBCC0\uC218**:");
+      for (const v of c.extractedVariables) {
+        lines.push(`- \`${v.name}\`: ${v.originalValue}`);
+      }
+      lines.push("");
+    }
+    if (c.suggestions.length > 0) {
+      lines.push("**\uAC1C\uC120 \uC81C\uC548**:");
+      for (const s of c.suggestions) {
+        lines.push(`- ${s}`);
+      }
+      lines.push("");
+    }
+    lines.push("**\uBBF8\uB9AC\uBCF4\uAE30** (\uCC98\uC74C 200\uC790):");
+    lines.push("```");
+    lines.push(c.originalText.slice(0, 200) + "...");
+    lines.push("```");
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push("\uC800\uC7A5\uD558\uB824\uBA74: `/ax-prompt save` \uB610\uB294 \uBC88\uD638 \uC120\uD0DD");
+  return lines.join("\n");
+}
+
+// src/tools/prompt/analyze.ts
+var SECTION_KEYWORDS = {
+  goal: ["\uBAA9\uD45C", "\uBAA9\uC801", "\uAC1C\uC694", "\uC18C\uAC1C", "\uBC30\uACBD"],
+  steps: ["\uB2E8\uACC4", "\uC808\uCC28", "\uC218\uD589", "\uC791\uC5C5", "\uBC29\uBC95", "\uAD6C\uD604"],
+  output: ["\uCD9C\uB825", "\uACB0\uACFC", "\uD615\uC2DD", "\uC0B0\uCD9C\uBB3C", "\uD15C\uD50C\uB9BF"],
+  validation: ["\uAC80\uC99D", "\uD655\uC778", "\uCCB4\uD06C", "\uD14C\uC2A4\uD2B8", "\uAC80\uC0AC", "\uAC80\uD1A0"]
+};
+var CATEGORY_KEYWORDS = {
+  planning: [
+    "\uACC4\uD68D",
+    "\uC124\uACC4",
+    "\uC804\uB7B5",
+    "\uB85C\uB4DC\uB9F5",
+    "\uB9C8\uC77C\uC2A4\uD1A4",
+    "\uC694\uAD6C\uC0AC\uD56D",
+    "\uBD84\uC11D",
+    "\uC544\uD0A4\uD14D\uCC98"
+  ],
+  quality: [
+    "\uB9AC\uBDF0",
+    "\uC810\uAC80",
+    "\uD488\uC9C8",
+    "\uD14C\uC2A4\uD2B8",
+    "\uAC80\uC99D",
+    "\uBCF4\uC548",
+    "\uC131\uB2A5",
+    "\uC811\uADFC\uC131"
+  ],
+  documentation: [
+    "\uBB38\uC11C",
+    "\uAC00\uC774\uB4DC",
+    "\uB9E4\uB274\uC5BC",
+    "API",
+    "README",
+    "\uC124\uBA85",
+    "\uD29C\uD1A0\uB9AC\uC5BC"
+  ],
+  workflow: [
+    "\uC6CC\uD06C\uD50C\uB85C\uC6B0",
+    "\uD504\uB85C\uC138\uC2A4",
+    "\uD30C\uC774\uD504\uB77C\uC778",
+    "\uC790\uB3D9\uD654",
+    "CI",
+    "CD",
+    "\uBC30\uD3EC",
+    "\uB9B4\uB9AC\uC2A4"
+  ]
+};
+var PROJECT_PATTERNS = {
+  path: /(?:src|packages|apps|lib|components)\/[\w\-\/]+\.(?:ts|tsx|js|jsx|md)/gi,
+  name: /\b[A-Z][a-z]+(?:[A-Z][a-z]+)+\b/g,
+  version: /\b\d+\.\d+\.\d+(?:-[\w.]+)?\b/g,
+  date: /\b\d{4}-\d{2}-\d{2}\b/g,
+  package: /@[\w-]+\/[\w-]+/g
+};
+function calculateRepeatability2(text) {
+  let score = 0;
+  const reasons = [];
+  const headerCount = (text.match(/^#{1,3}\s/gm) || []).length;
+  if (headerCount >= 3) {
+    score += 8;
+    reasons.push(`${headerCount}\uAC1C \uC139\uC158 \uAD6C\uC870 \uBC1C\uACAC`);
+  } else if (headerCount > 0) {
+    score += 4;
+    reasons.push(`${headerCount}\uAC1C \uC139\uC158 \uC874\uC7AC`);
+  }
+  const listCount = (text.match(/^[\-\*]\s/gm) || []).length;
+  const numberedCount = (text.match(/^\d+\.\s/gm) || []).length;
+  if (listCount + numberedCount >= 5) {
+    score += 8;
+    reasons.push("\uCCB4\uACC4\uC801\uC778 \uB9AC\uC2A4\uD2B8 \uAD6C\uC870");
+  } else if (listCount + numberedCount > 0) {
+    score += 4;
+    reasons.push("\uB9AC\uC2A4\uD2B8 \uAD6C\uC870 \uC874\uC7AC");
+  }
+  const structuredKeywords = [
+    ...SECTION_KEYWORDS.goal,
+    ...SECTION_KEYWORDS.steps
+  ];
+  const keywordMatches = structuredKeywords.filter(
+    (k) => text.includes(k)
+  ).length;
+  if (keywordMatches >= 3) {
+    score += 9;
+    reasons.push("\uAD6C\uC870\uD654 \uD0A4\uC6CC\uB4DC \uB2E4\uC218 \uD3EC\uD568");
+  } else if (keywordMatches > 0) {
+    score += 4;
+    reasons.push(`${keywordMatches}\uAC1C \uAD6C\uC870\uD654 \uD0A4\uC6CC\uB4DC`);
+  }
+  return {
+    score: Math.min(25, score),
+    feedback: reasons.length > 0 ? reasons.join(", ") : "\uAD6C\uC870\uD654 \uD328\uD134 \uBD80\uC871"
+  };
+}
+function calculateGenerality2(text) {
+  let score = 30;
+  const reasons = [];
+  const projectValues = [];
+  const paths = text.match(PROJECT_PATTERNS.path);
+  if (paths) {
+    score -= Math.min(8, paths.length * 2);
+    reasons.push(`${paths.length}\uAC1C \uD30C\uC77C \uACBD\uB85C \uAC10\uC9C0`);
+    paths.forEach(
+      (p) => projectValues.push({
+        value: p,
+        type: "path",
+        suggestedVariable: "{{FILE_PATH}}"
+      })
+    );
+  }
+  const versions = text.match(PROJECT_PATTERNS.version);
+  if (versions) {
+    score -= Math.min(4, versions.length);
+    reasons.push(`${versions.length}\uAC1C \uBC84\uC804 \uAC10\uC9C0`);
+    versions.forEach(
+      (v) => projectValues.push({
+        value: v,
+        type: "version",
+        suggestedVariable: "{{VERSION}}"
+      })
+    );
+  }
+  const dates = text.match(PROJECT_PATTERNS.date);
+  if (dates) {
+    score -= Math.min(4, dates.length);
+    reasons.push(`${dates.length}\uAC1C \uB0A0\uC9DC \uAC10\uC9C0`);
+    dates.forEach(
+      (d) => projectValues.push({
+        value: d,
+        type: "date",
+        suggestedVariable: "{{DATE}}"
+      })
+    );
+  }
+  const packages = text.match(PROJECT_PATTERNS.package);
+  if (packages) {
+    score -= Math.min(6, packages.length * 2);
+    reasons.push(`${packages.length}\uAC1C \uD328\uD0A4\uC9C0\uBA85 \uAC10\uC9C0`);
+    packages.forEach(
+      (p) => projectValues.push({
+        value: p,
+        type: "name",
+        suggestedVariable: "{{PACKAGE_NAME}}"
+      })
+    );
+  }
+  const names = text.match(PROJECT_PATTERNS.name);
+  if (names) {
+    const filteredNames = names.filter(
+      (n) => ![
+        "README",
+        "TypeScript",
+        "JavaScript",
+        "React",
+        "Next",
+        "Node"
+      ].includes(n)
+    );
+    if (filteredNames.length > 0) {
+      score -= Math.min(8, filteredNames.length * 2);
+      reasons.push(`${filteredNames.length}\uAC1C \uACE0\uC720\uBA85 \uAC10\uC9C0`);
+      filteredNames.forEach(
+        (n) => projectValues.push({
+          value: n,
+          type: "name",
+          suggestedVariable: "{{COMPONENT_NAME}}"
+        })
+      );
+    }
+  }
+  return {
+    score: Math.max(0, score),
+    feedback: reasons.length > 0 ? reasons.join(", ") : "\uD504\uB85C\uC81D\uD2B8 \uC885\uC18D\uC131 \uB0AE\uC74C",
+    projectValues
+  };
+}
+function calculateIndependence2(text) {
+  let score = 25;
+  const reasons = [];
+  const contextPhrases = [
+    "\uC704\uC5D0\uC11C",
+    "\uC55E\uC11C",
+    "\uC774\uC804\uC5D0",
+    "\uC544\uAE4C",
+    "\uC704 \uCF54\uB4DC",
+    "\uC544\uB798 \uCF54\uB4DC",
+    "\uB9D0\uC500\uD558\uC2E0",
+    "\uC694\uCCAD\uD558\uC2E0"
+  ];
+  for (const phrase of contextPhrases) {
+    if (text.includes(phrase)) {
+      score -= 5;
+      reasons.push(`"${phrase}" \uD45C\uD604 \uD3EC\uD568`);
+    }
+  }
+  const pronounPatterns = [/그것[을이가]/g, /이것[을이가]/g, /저것[을이가]/g];
+  for (const pattern of pronounPatterns) {
+    if (pattern.test(text)) {
+      score -= 3;
+      reasons.push("\uB300\uBA85\uC0AC \uCC38\uC870 \uD3EC\uD568");
+      break;
+    }
+  }
+  return {
+    score: Math.max(0, score),
+    feedback: reasons.length > 0 ? reasons.join(", ") : "\uB3C5\uB9BD\uC801\uC73C\uB85C \uB3D9\uC791 \uAC00\uB2A5"
+  };
+}
+function calculateClarity2(text) {
+  let score = 0;
+  const reasons = [];
+  if (SECTION_KEYWORDS.goal.some((k) => text.includes(`## ${k}`) || text.includes(`### ${k}`))) {
+    score += 5;
+    reasons.push("\uBAA9\uD45C \uC139\uC158 \uC874\uC7AC");
+  }
+  if (SECTION_KEYWORDS.steps.some((k) => text.includes(`## ${k}`) || text.includes(`### ${k}`))) {
+    score += 5;
+    reasons.push("\uC218\uD589 \uB2E8\uACC4 \uC139\uC158 \uC874\uC7AC");
+  }
+  if (text.includes("```") && SECTION_KEYWORDS.output.some((k) => text.includes(k))) {
+    score += 5;
+    reasons.push("\uCD9C\uB825 \uD615\uC2DD \uC815\uC758\uB428");
+  }
+  if (/\[[\sx]\]/i.test(text)) {
+    score += 5;
+    reasons.push("\uAC80\uC99D \uCCB4\uD06C\uB9AC\uC2A4\uD2B8 \uD3EC\uD568");
+  }
+  return {
+    score: Math.min(20, score),
+    feedback: reasons.length > 0 ? reasons.join(", ") : "\uBA85\uD655\uC131 \uAC1C\uC120 \uD544\uC694"
+  };
+}
+function suggestCategory2(text) {
+  const scores = {
+    planning: 0,
+    quality: 0,
+    documentation: 0,
+    workflow: 0
+  };
+  for (const [category, keywords] of Object.entries(CATEGORY_KEYWORDS)) {
+    for (const keyword of keywords) {
+      const regex = new RegExp(keyword, "gi");
+      const matches = text.match(regex);
+      if (matches) {
+        scores[category] += matches.length;
+      }
+    }
+  }
+  const entries = Object.entries(scores);
+  entries.sort((a, b) => b[1] - a[1]);
+  return entries[0][0];
+}
+function extractSections(text) {
+  const sections = {};
+  for (const keyword of SECTION_KEYWORDS.goal) {
+    const goalMatch = text.match(
+      new RegExp(`##?#?\\s*${keyword}[\\s\\S]*?(?=##|$)`, "i")
+    );
+    if (goalMatch) {
+      sections.goal = goalMatch[0].trim();
+      break;
+    }
+  }
+  const stepMatches = text.match(/^\d+\.\s+.+$/gm);
+  if (stepMatches) {
+    sections.steps = stepMatches.map((s) => s.replace(/^\d+\.\s+/, ""));
+  }
+  for (const keyword of SECTION_KEYWORDS.output) {
+    const outputMatch = text.match(
+      new RegExp(`##?#?\\s*${keyword}[\\s\\S]*?(?=##|$)`, "i")
+    );
+    if (outputMatch) {
+      sections.output = outputMatch[0].trim();
+      break;
+    }
+  }
+  const validationMatches = text.match(/^\s*\[[\sx]\]\s*.+$/gim);
+  if (validationMatches) {
+    sections.validation = validationMatches.map(
+      (v) => v.replace(/^\s*\[[\sx]\]\s*/, "")
+    );
+  }
+  return sections;
+}
+function handleAnalyze(params) {
+  const { text } = params;
+  if (!text || text.trim() === "") {
+    throw new Error("\uBD84\uC11D\uD560 \uD14D\uC2A4\uD2B8(text)\uB294 \uD544\uC218\uC785\uB2C8\uB2E4.");
+  }
+  const repeatability = calculateRepeatability2(text);
+  const generality = calculateGenerality2(text);
+  const independence = calculateIndependence2(text);
+  const clarity = calculateClarity2(text);
+  const scores = {
+    repeatability: repeatability.score,
+    generality: generality.score,
+    independence: independence.score,
+    clarity: clarity.score,
+    total: repeatability.score + generality.score + independence.score + clarity.score
+  };
+  return {
+    text,
+    scores,
+    feedback: {
+      repeatability: repeatability.feedback,
+      generality: generality.feedback,
+      independence: independence.feedback,
+      clarity: clarity.feedback
+    },
+    suggestedCategory: suggestCategory2(text),
+    isCandidate: scores.total >= 70,
+    sections: extractSections(text),
+    projectSpecificValues: generality.projectValues
+  };
+}
+function formatAnalyzeResult(result) {
+  const lines = [];
+  lines.push("## \uD504\uB86C\uD504\uD2B8 \uBD84\uC11D");
+  lines.push("");
+  lines.push(`**\uCD1D\uC810**: ${result.scores.total}/100`);
+  lines.push(
+    `**\uC7AC\uC0AC\uC6A9 \uC801\uD569**: ${result.isCandidate ? "\u2705 \uC608 (70\uC810 \uC774\uC0C1)" : "\u274C \uC544\uB2C8\uC624"}`
+  );
+  lines.push(`**\uCD94\uCC9C \uCE74\uD14C\uACE0\uB9AC**: ${result.suggestedCategory}`);
+  lines.push("");
+  lines.push("### \uC810\uC218 \uC0C1\uC138");
+  lines.push("");
+  lines.push("| \uD56D\uBAA9 | \uC810\uC218 | \uD53C\uB4DC\uBC31 |");
+  lines.push("|------|------|--------|");
+  lines.push(
+    `| \uBC18\uBCF5\uC131 | ${result.scores.repeatability}/25 | ${result.feedback.repeatability} |`
+  );
+  lines.push(
+    `| \uBC94\uC6A9\uC131 | ${result.scores.generality}/30 | ${result.feedback.generality} |`
+  );
+  lines.push(
+    `| \uB3C5\uB9BD\uC131 | ${result.scores.independence}/25 | ${result.feedback.independence} |`
+  );
+  lines.push(
+    `| \uBA85\uD655\uC131 | ${result.scores.clarity}/20 | ${result.feedback.clarity} |`
+  );
+  lines.push("");
+  if (result.projectSpecificValues.length > 0) {
+    lines.push("### \uD504\uB85C\uC81D\uD2B8 \uC885\uC18D \uAC12 (\uBCC0\uC218\uD654 \uB300\uC0C1)");
+    lines.push("");
+    lines.push("| \uC6D0\uBCF8 \uAC12 | \uC720\uD615 | \uC81C\uC548 \uBCC0\uC218 |");
+    lines.push("|---------|------|-----------|");
+    for (const v of result.projectSpecificValues) {
+      lines.push(`| \`${v.value}\` | ${v.type} | \`${v.suggestedVariable}\` |`);
+    }
+    lines.push("");
+  }
+  if (Object.keys(result.sections).length > 0) {
+    lines.push("### \uCD94\uCD9C\uB41C \uC139\uC158");
+    lines.push("");
+    if (result.sections.goal) {
+      lines.push("- \u2705 \uBAA9\uD45C \uC139\uC158");
+    }
+    if (result.sections.steps) {
+      lines.push(`- \u2705 \uB2E8\uACC4 (${result.sections.steps.length}\uAC1C)`);
+    }
+    if (result.sections.output) {
+      lines.push("- \u2705 \uCD9C\uB825 \uD615\uC2DD");
+    }
+    if (result.sections.validation) {
+      lines.push(`- \u2705 \uAC80\uC99D \uD56D\uBAA9 (${result.sections.validation.length}\uAC1C)`);
+    }
+    lines.push("");
+  }
+  const suggestions = [];
+  if (result.scores.repeatability < 15) {
+    suggestions.push("\uAD6C\uC870\uD654\uB41C \uC139\uC158 (\uBAA9\uD45C, \uB2E8\uACC4, \uCD9C\uB825) \uCD94\uAC00 \uAD8C\uC7A5");
+  }
+  if (result.scores.generality < 20) {
+    suggestions.push("\uD504\uB85C\uC81D\uD2B8 \uD2B9\uC815 \uAC12\uC744 \uBCC0\uC218\uB85C \uB300\uCCB4 \uD544\uC694");
+  }
+  if (result.scores.independence < 15) {
+    suggestions.push("\uCEE8\uD14D\uC2A4\uD2B8 \uC758\uC874 \uD45C\uD604 \uC81C\uAC70 \uD544\uC694");
+  }
+  if (result.scores.clarity < 12) {
+    suggestions.push("\uCD9C\uB825 \uD615\uC2DD \uBC0F \uAC80\uC99D \uCCB4\uD06C\uB9AC\uC2A4\uD2B8 \uCD94\uAC00 \uAD8C\uC7A5");
+  }
+  if (suggestions.length > 0) {
+    lines.push("### \uAC1C\uC120 \uC81C\uC548");
+    lines.push("");
+    for (const s of suggestions) {
+      lines.push(`- ${s}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/tools/prompt/refine.ts
+var VARIABLE_PATTERNS = [
+  {
+    pattern: /(?:src|packages|apps|lib|components)\/[\w\-\/]+\.(?:ts|tsx|js|jsx|md)/gi,
+    variable: "{{FILE_PATH}}",
+    description: "\uD30C\uC77C \uACBD\uB85C",
+    type: "path"
+  },
+  {
+    pattern: /\b\d+\.\d+\.\d+(?:-[\w.]+)?\b/g,
+    variable: "{{VERSION}}",
+    description: "\uBC84\uC804 \uBC88\uD638",
+    type: "version"
+  },
+  {
+    pattern: /\b\d{4}-\d{2}-\d{2}\b/g,
+    variable: "{{DATE}}",
+    description: "\uB0A0\uC9DC",
+    type: "date"
+  },
+  {
+    pattern: /@[\w-]+\/[\w-]+/g,
+    variable: "{{PACKAGE_NAME}}",
+    description: "\uD328\uD0A4\uC9C0\uBA85",
+    type: "package"
+  }
+];
+var COMPONENT_PATTERN = /\b[A-Z][a-z]+(?:[A-Z][a-z]+)+\b/g;
+var COMMON_WORDS = [
+  "README",
+  "TypeScript",
+  "JavaScript",
+  "React",
+  "Next",
+  "Node",
+  "Tailwind",
+  "WCAG",
+  "HTML",
+  "CSS",
+  "JSON",
+  "YAML",
+  "API",
+  "REST",
+  "GraphQL"
+];
+var CATEGORY_INFERENCE = {
+  \uACC4\uD68D: "planning",
+  \uC124\uACC4: "planning",
+  \uC804\uB7B5: "planning",
+  \uC694\uAD6C\uC0AC\uD56D: "planning",
+  \uB9AC\uBDF0: "quality",
+  \uC810\uAC80: "quality",
+  \uD14C\uC2A4\uD2B8: "quality",
+  \uAC80\uC99D: "quality",
+  \uBB38\uC11C: "documentation",
+  \uAC00\uC774\uB4DC: "documentation",
+  \uB9E4\uB274\uC5BC: "documentation",
+  \uC6CC\uD06C\uD50C\uB85C\uC6B0: "workflow",
+  \uD504\uB85C\uC138\uC2A4: "workflow",
+  \uC790\uB3D9\uD654: "workflow"
+};
+function generatePromptName(text) {
+  const headerMatch = text.match(/^#\s+(.+)$/m);
+  if (headerMatch) {
+    return headerMatch[1].toLowerCase().replace(/[^a-z가-힣0-9\s]/g, "").trim().replace(/\s+/g, "-").slice(0, 30);
+  }
+  for (const keyword of Object.keys(CATEGORY_INFERENCE)) {
+    if (text.includes(keyword)) {
+      return `${keyword}-prompt`.replace(/\s+/g, "-");
+    }
+  }
+  return "custom-prompt";
+}
+function inferCategory(text, providedCategory) {
+  if (providedCategory) return providedCategory;
+  for (const [keyword, category] of Object.entries(CATEGORY_INFERENCE)) {
+    if (text.includes(keyword)) {
+      return category;
+    }
+  }
+  return "workflow";
+}
+function extractAndReplaceVariables(text) {
+  const variables = [];
+  const transformations = [];
+  const seen = /* @__PURE__ */ new Map();
+  let refinedText = text;
+  for (const { pattern, variable, description, type } of VARIABLE_PATTERNS) {
+    const matches = refinedText.match(pattern);
+    if (matches) {
+      for (const match of matches) {
+        if (!seen.has(match)) {
+          seen.set(match, variable);
+          const existingVars = variables.filter((v) => v.name.startsWith(variable.replace("}}", "")));
+          const varName = existingVars.length > 0 ? variable.replace("}}", `_${existingVars.length + 1}}`) : variable;
+          variables.push({
+            name: varName,
+            description,
+            originalValue: match,
+            example: match,
+            required: true
+          });
+          transformations.push({
+            original: match,
+            replacement: varName,
+            type
+          });
+          refinedText = refinedText.split(match).join(varName);
+        }
+      }
+    }
+  }
+  const componentMatches = refinedText.match(COMPONENT_PATTERN);
+  if (componentMatches) {
+    const uniqueComponents = [...new Set(componentMatches)].filter(
+      (c) => !COMMON_WORDS.includes(c)
+    );
+    for (const comp of uniqueComponents) {
+      if (!seen.has(comp)) {
+        const existingVars = variables.filter(
+          (v) => v.name.startsWith("{{COMPONENT_NAME")
+        );
+        const varName = existingVars.length > 0 ? `{{COMPONENT_NAME_${existingVars.length + 1}}}` : "{{COMPONENT_NAME}}";
+        seen.set(comp, varName);
+        variables.push({
+          name: varName,
+          description: "\uCEF4\uD3EC\uB10C\uD2B8/\uAE30\uB2A5\uBA85",
+          originalValue: comp,
+          example: comp,
+          required: true
+        });
+        transformations.push({
+          original: comp,
+          replacement: varName,
+          type: "component"
+        });
+        refinedText = refinedText.split(comp).join(varName);
+      }
+    }
+  }
+  return { refinedText, variables, transformations };
+}
+function generateFrontmatter(name, category, description, variables) {
+  const lines = [];
+  lines.push("---");
+  lines.push(`name: ${name}`);
+  lines.push(`category: ${category}`);
+  lines.push(`description: ${description}`);
+  if (variables.length > 0) {
+    lines.push("variables:");
+    for (const v of variables) {
+      lines.push(`  - name: "${v.name}"`);
+      lines.push(`    description: ${v.description}`);
+      if (v.example) {
+        lines.push(`    example: ${v.example}`);
+      }
+      if (v.required !== void 0) {
+        lines.push(`    required: ${v.required}`);
+      }
+    }
+  }
+  lines.push("---");
+  return lines.join("\n");
+}
+function extractDescription(text) {
+  const firstParagraph = text.match(/^[^#\n].+$/m);
+  if (firstParagraph) {
+    return firstParagraph[0].slice(0, 100).trim();
+  }
+  const goalMatch = text.match(/##?\s*목표[\s\S]*?(?=##|$)/i);
+  if (goalMatch) {
+    const goalText = goalMatch[0].replace(/##?\s*목표\s*/i, "").trim();
+    return goalText.slice(0, 100);
+  }
+  return "\uC7AC\uC0AC\uC6A9 \uAC00\uB2A5\uD55C \uD504\uB86C\uD504\uD2B8";
+}
+function handleRefine(params) {
+  const { text, name: providedName, category: providedCategory } = params;
+  if (!text || text.trim() === "") {
+    throw new Error("\uC815\uC81C\uD560 \uD14D\uC2A4\uD2B8(text)\uB294 \uD544\uC218\uC785\uB2C8\uB2E4.");
+  }
+  const { refinedText, variables, transformations } = extractAndReplaceVariables(text);
+  const name = providedName || generatePromptName(text);
+  const category = inferCategory(text, providedCategory);
+  const description = extractDescription(text);
+  const frontmatter = generateFrontmatter(name, category, description, variables);
+  const finalText = `${frontmatter}
+
+${refinedText.trim()}`;
+  return {
+    refinedText: finalText,
+    frontmatter,
+    variables,
+    transformations,
+    metadata: {
+      name,
+      category,
+      description,
+      variables
+    }
+  };
+}
+function formatRefineResult(result) {
+  const lines = [];
+  lines.push("## \uC815\uC81C \uACB0\uACFC");
+  lines.push("");
+  lines.push(`**\uC774\uB984**: \`${result.metadata.name}\``);
+  lines.push(`**\uCE74\uD14C\uACE0\uB9AC**: \`${result.metadata.category}\``);
+  lines.push(`**\uC124\uBA85**: ${result.metadata.description}`);
+  lines.push("");
+  if (result.transformations.length > 0) {
+    lines.push("### \uBCC0\uD658 \uB0B4\uC5ED");
+    lines.push("");
+    lines.push("| \uC6D0\uBCF8 | \uBCC0\uC218 | \uC720\uD615 |");
+    lines.push("|------|------|------|");
+    for (const t of result.transformations) {
+      lines.push(`| \`${t.original}\` | \`${t.replacement}\` | ${t.type} |`);
+    }
+    lines.push("");
+  }
+  if (result.variables.length > 0) {
+    lines.push("### \uBCC0\uC218 \uBAA9\uB85D");
+    lines.push("");
+    lines.push("| \uBCC0\uC218 | \uC124\uBA85 | \uC608\uC2DC |");
+    lines.push("|------|------|------|");
+    for (const v of result.variables) {
+      lines.push(`| \`${v.name}\` | ${v.description} | ${v.example || "-"} |`);
+    }
+    lines.push("");
+  }
+  lines.push("### \uC815\uC81C\uB41C \uD504\uB86C\uD504\uD2B8 \uBBF8\uB9AC\uBCF4\uAE30");
+  lines.push("");
+  lines.push("```markdown");
+  lines.push(result.refinedText.slice(0, 1e3));
+  if (result.refinedText.length > 1e3) {
+    lines.push("...(truncated)");
+  }
+  lines.push("```");
+  lines.push("");
+  lines.push("---");
+  lines.push(`\uC800\uC7A5\uD558\uB824\uBA74: \`/ax-prompt save --name=${result.metadata.name} --category=${result.metadata.category}\``);
+  return lines.join("\n");
+}
+
+// src/tools/prompt/validate.ts
+import * as fs from "fs";
+import * as path from "path";
+var INDEX_PATH = ".claude/prompts/_registry/prompt-index.json";
+function parseFrontmatter(text) {
+  const match = text.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) {
+    return { valid: false, error: "\uD504\uB860\uD2B8\uB9E4\uD130\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4" };
+  }
+  try {
+    const yaml = match[1];
+    const data = {};
+    const lines = yaml.split("\n");
+    let currentKey = "";
+    let currentArray = null;
+    for (const line of lines) {
+      if (line.trim().startsWith("- ") && currentArray) {
+        currentArray.push(line.trim().substring(2));
+        continue;
+      }
+      const kvMatch = line.match(/^(\w+):\s*(.*)$/);
+      if (kvMatch) {
+        if (currentArray && currentKey) {
+          data[currentKey] = currentArray;
+        }
+        currentKey = kvMatch[1];
+        const value = kvMatch[2].trim();
+        if (value === "") {
+          currentArray = [];
+        } else {
+          data[currentKey] = value;
+          currentArray = null;
+        }
+      }
+    }
+    if (currentArray && currentKey) {
+      data[currentKey] = currentArray;
+    }
+    if (!data.name) {
+      return { valid: false, error: "name \uD544\uB4DC\uAC00 \uD544\uC694\uD569\uB2C8\uB2E4" };
+    }
+    if (!data.category) {
+      return { valid: false, error: "category \uD544\uB4DC\uAC00 \uD544\uC694\uD569\uB2C8\uB2E4" };
+    }
+    const validCategories = ["planning", "quality", "documentation", "workflow"];
+    if (!validCategories.includes(data.category)) {
+      return {
+        valid: false,
+        error: `\uC720\uD6A8\uD558\uC9C0 \uC54A\uC740 category: ${data.category}. \uD5C8\uC6A9\uAC12: ${validCategories.join(", ")}`
+      };
+    }
+    return { valid: true, data };
+  } catch (error) {
+    return {
+      valid: false,
+      error: `YAML \uD30C\uC2F1 \uC624\uB958: ${error instanceof Error ? error.message : "\uC54C \uC218 \uC5C6\uB294 \uC624\uB958"}`
+    };
+  }
+}
+function checkRequiredSections(text) {
+  const details = [];
+  const goalKeywords = ["\uBAA9\uD45C", "\uBAA9\uC801", "\uAC1C\uC694"];
+  const hasGoal = goalKeywords.some(
+    (k) => text.includes(`## ${k}`) || text.includes(`### ${k}`)
+  );
+  if (!hasGoal) {
+    details.push("\uBAA9\uD45C/\uAC1C\uC694 \uC139\uC158\uC774 \uAD8C\uC7A5\uB429\uB2C8\uB2E4");
+  }
+  const stepKeywords = ["\uB2E8\uACC4", "\uC808\uCC28", "\uC218\uD589"];
+  const hasSteps = stepKeywords.some(
+    (k) => text.includes(`## ${k}`) || text.includes(`### ${k}`)
+  ) || /^\d+\.\s/m.test(text);
+  if (!hasSteps) {
+    details.push("\uC218\uD589 \uB2E8\uACC4 \uC139\uC158\uC774 \uAD8C\uC7A5\uB429\uB2C8\uB2E4");
+  }
+  return {
+    hasGoal,
+    hasSteps,
+    details
+  };
+}
+function checkHardcodedPaths(text) {
+  const hardcodedPatterns = [
+    // 절대 경로 (변수화되지 않은)
+    /(?<!{{)(?:src|packages|apps|lib|components)\/[\w\-\/]+\.(?:ts|tsx|js|jsx|md)(?!}})/gi,
+    // 특정 프로젝트 경로
+    /D:\\|C:\\|\/Users\/|\/home\//gi
+  ];
+  const found = [];
+  for (const pattern of hardcodedPatterns) {
+    const matches = text.match(pattern);
+    if (matches) {
+      found.push(...matches);
+    }
+  }
+  return {
+    clean: found.length === 0,
+    found
+  };
+}
+function checkVariablesDocumented(text) {
+  const usedVariables = text.match(/{{[A-Z_]+}}/g) || [];
+  const uniqueVariables = [...new Set(usedVariables)];
+  const frontmatterMatch = text.match(/^---\n([\s\S]*?)\n---/);
+  const frontmatter = frontmatterMatch ? frontmatterMatch[1] : "";
+  const undocumented = [];
+  for (const variable of uniqueVariables) {
+    if (!frontmatter.includes(variable)) {
+      undocumented.push(variable);
+    }
+  }
+  return {
+    documented: undocumented.length === 0,
+    undocumented
+  };
+}
+function checkDuplicate(text, _basePath) {
+  const similar = [];
+  try {
+    const indexPath = path.resolve(process.cwd(), INDEX_PATH);
+    if (!fs.existsSync(indexPath)) {
+      return { noDuplicate: true, similar };
+    }
+    const indexContent = fs.readFileSync(indexPath, "utf-8");
+    const index = JSON.parse(indexContent);
+    const textKeywords = extractKeywords(text);
+    for (const prompt of index.prompts) {
+      const promptPath = path.resolve(process.cwd(), prompt.path);
+      if (!fs.existsSync(promptPath)) continue;
+      const promptContent = fs.readFileSync(promptPath, "utf-8");
+      const promptKeywords = extractKeywords(promptContent);
+      const similarity = calculateSimilarity(textKeywords, promptKeywords);
+      if (similarity >= 0.6) {
+        similar.push({
+          id: prompt.id,
+          name: prompt.name,
+          similarity: Math.round(similarity * 100)
+        });
+      }
+    }
+    return {
+      noDuplicate: !similar.some((s) => s.similarity >= 80),
+      similar: similar.sort((a, b) => b.similarity - a.similarity)
+    };
+  } catch {
+    return { noDuplicate: true, similar };
+  }
+}
+function extractKeywords(text) {
+  const words = text.toLowerCase().replace(/[^a-z가-힣\s]/g, " ").split(/\s+/).filter((w) => w.length > 2);
+  return new Set(words);
+}
+function calculateSimilarity(set1, set2) {
+  const intersection = new Set([...set1].filter((x) => set2.has(x)));
+  const union = /* @__PURE__ */ new Set([...set1, ...set2]);
+  return intersection.size / union.size;
+}
+function handleValidate(params) {
+  const { promptText, checkDuplicate: enableDuplicateCheck = true } = params;
+  if (!promptText || promptText.trim() === "") {
+    throw new Error("\uAC80\uC99D\uD560 \uD504\uB86C\uD504\uD2B8(promptText)\uB294 \uD544\uC218\uC785\uB2C8\uB2E4.");
+  }
+  const errors = [];
+  const frontmatterResult = parseFrontmatter(promptText);
+  if (!frontmatterResult.valid) {
+    errors.push({
+      code: "INVALID_FRONTMATTER",
+      message: frontmatterResult.error || "\uD504\uB860\uD2B8\uB9E4\uD130 \uC624\uB958",
+      severity: "error"
+    });
+  }
+  const sectionResult = checkRequiredSections(promptText);
+  for (const detail of sectionResult.details) {
+    errors.push({
+      code: "MISSING_SECTION",
+      message: detail,
+      severity: "warning"
+    });
+  }
+  const pathResult = checkHardcodedPaths(promptText);
+  if (!pathResult.clean) {
+    errors.push({
+      code: "HARDCODED_PATH",
+      message: `\uD558\uB4DC\uCF54\uB529\uB41C \uACBD\uB85C \uBC1C\uACAC: ${pathResult.found.slice(0, 3).join(", ")}${pathResult.found.length > 3 ? "..." : ""}`,
+      severity: "error"
+    });
+  }
+  const varResult = checkVariablesDocumented(promptText);
+  if (!varResult.documented) {
+    errors.push({
+      code: "UNDOCUMENTED_VARIABLE",
+      message: `\uBB38\uC11C\uD654\uB418\uC9C0 \uC54A\uC740 \uBCC0\uC218: ${varResult.undocumented.join(", ")}`,
+      severity: "warning"
+    });
+  }
+  let duplicateResult = { noDuplicate: true, similar: void 0 };
+  if (enableDuplicateCheck) {
+    duplicateResult = checkDuplicate(promptText);
+    if (!duplicateResult.noDuplicate) {
+      const mostSimilar = duplicateResult.similar?.[0];
+      errors.push({
+        code: "DUPLICATE_PROMPT",
+        message: `\uC720\uC0AC \uD504\uB86C\uD504\uD2B8 \uC874\uC7AC: ${mostSimilar?.name} (${mostSimilar?.similarity}% \uC720\uC0AC)`,
+        severity: "error"
+      });
+    }
+  }
+  const hasErrors = errors.some((e) => e.severity === "error");
+  return {
+    isValid: !hasErrors,
+    errors,
+    checklist: {
+      hasRequiredSections: sectionResult.hasGoal && sectionResult.hasSteps,
+      noHardcodedPaths: pathResult.clean,
+      variablesDocumented: varResult.documented,
+      validFrontmatter: frontmatterResult.valid,
+      noDuplicate: duplicateResult.noDuplicate
+    },
+    similarPrompts: duplicateResult.similar
+  };
+}
+function formatValidateResult(result) {
+  const lines = [];
+  lines.push("## \uAC80\uC99D \uACB0\uACFC");
+  lines.push("");
+  lines.push(`**\uC720\uD6A8\uC131**: ${result.isValid ? "\u2705 \uD1B5\uACFC" : "\u274C \uC2E4\uD328"}`);
+  lines.push("");
+  lines.push("### \uCCB4\uD06C\uB9AC\uC2A4\uD2B8");
+  lines.push("");
+  lines.push(
+    `- [${result.checklist.validFrontmatter ? "x" : " "}] YAML \uD504\uB860\uD2B8\uB9E4\uD130 \uC720\uD6A8`
+  );
+  lines.push(
+    `- [${result.checklist.hasRequiredSections ? "x" : " "}] \uD544\uC218 \uC139\uC158 \uC874\uC7AC (\uBAA9\uD45C, \uB2E8\uACC4)`
+  );
+  lines.push(
+    `- [${result.checklist.noHardcodedPaths ? "x" : " "}] \uD558\uB4DC\uCF54\uB529 \uACBD\uB85C \uC5C6\uC74C`
+  );
+  lines.push(
+    `- [${result.checklist.variablesDocumented ? "x" : " "}] \uBCC0\uC218 \uBB38\uC11C\uD654 \uC644\uB8CC`
+  );
+  lines.push(
+    `- [${result.checklist.noDuplicate ? "x" : " "}] \uC911\uBCF5 \uD504\uB86C\uD504\uD2B8 \uC5C6\uC74C`
+  );
+  lines.push("");
+  if (result.errors.length > 0) {
+    lines.push("### \uBC1C\uACAC\uB41C \uBB38\uC81C");
+    lines.push("");
+    const errorItems = result.errors.filter((e) => e.severity === "error");
+    const warningItems = result.errors.filter((e) => e.severity === "warning");
+    if (errorItems.length > 0) {
+      lines.push("**\uC624\uB958** (\uC218\uC815 \uD544\uC218):");
+      for (const e of errorItems) {
+        lines.push(`- \u274C [${e.code}] ${e.message}`);
+      }
+      lines.push("");
+    }
+    if (warningItems.length > 0) {
+      lines.push("**\uACBD\uACE0** (\uAD8C\uC7A5 \uC218\uC815):");
+      for (const w of warningItems) {
+        lines.push(`- \u26A0\uFE0F [${w.code}] ${w.message}`);
+      }
+      lines.push("");
+    }
+  }
+  if (result.similarPrompts && result.similarPrompts.length > 0) {
+    lines.push("### \uC720\uC0AC \uD504\uB86C\uD504\uD2B8");
+    lines.push("");
+    lines.push("| \uD504\uB86C\uD504\uD2B8 | \uC720\uC0AC\uB3C4 |");
+    lines.push("|----------|--------|");
+    for (const s of result.similarPrompts.slice(0, 3)) {
+      lines.push(`| ${s.name} | ${s.similarity}% |`);
+    }
+    lines.push("");
+    lines.push("*80% \uC774\uC0C1 \uC720\uC0AC \uC2DC \uC911\uBCF5\uC73C\uB85C \uAC04\uC8FC\uB429\uB2C8\uB2E4.*");
+    lines.push("");
+  }
+  if (result.isValid) {
+    lines.push("---");
+    lines.push("\uAC80\uC99D \uD1B5\uACFC! `/ax-prompt save`\uB85C \uC800\uC7A5\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4.");
+  } else {
+    lines.push("---");
+    lines.push("\uC624\uB958\uB97C \uC218\uC815\uD55C \uD6C4 \uB2E4\uC2DC \uAC80\uC99D\uD558\uC138\uC694.");
+  }
+  return lines.join("\n");
+}
+
+// src/tools/prompt/save.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+var PROMPTS_BASE_PATH = ".claude/prompts";
+var INDEX_PATH2 = ".claude/prompts/_registry/prompt-index.json";
+function extractMetadata(promptText) {
+  const match = promptText.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return null;
+  const yaml = match[1];
+  const lines = yaml.split("\n");
+  let name = "";
+  let category = "workflow";
+  let description = "";
+  const variables = [];
+  let inVariables = false;
+  for (const line of lines) {
+    if (line.startsWith("name:")) {
+      name = line.replace("name:", "").trim();
+    } else if (line.startsWith("category:")) {
+      category = line.replace("category:", "").trim();
+    } else if (line.startsWith("description:")) {
+      description = line.replace("description:", "").trim();
+    } else if (line.startsWith("variables:")) {
+      inVariables = true;
+    } else if (inVariables && line.includes("name:")) {
+      const varMatch = line.match(/name:\s*"?({{[A-Z_]+}})"?/);
+      if (varMatch) {
+        variables.push(varMatch[1]);
+      }
+    }
+  }
+  if (!name || !category) return null;
+  return { name, category, description, variables };
+}
+function loadIndex(basePath) {
+  const indexPath = path2.join(basePath, INDEX_PATH2);
+  if (!fs2.existsSync(indexPath)) {
+    return {
+      version: "1.0.0",
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+      categories: {
+        planning: { description: "\uACC4\uD68D \uC218\uB9BD", count: 0 },
+        quality: { description: "\uD488\uC9C8 \uAD00\uB9AC", count: 0 },
+        documentation: { description: "\uBB38\uC11C\uD654", count: 0 },
+        workflow: { description: "\uC6CC\uD06C\uD50C\uB85C\uC6B0", count: 0 }
+      },
+      prompts: [],
+      stats: {
+        totalPrompts: 0,
+        totalUsage: 0,
+        mostUsed: null,
+        recentlyAdded: null
+      }
+    };
+  }
+  const content = fs2.readFileSync(indexPath, "utf-8");
+  return JSON.parse(content);
+}
+function saveIndex(basePath, index) {
+  const indexPath = path2.join(basePath, INDEX_PATH2);
+  const indexDir = path2.dirname(indexPath);
+  if (!fs2.existsSync(indexDir)) {
+    fs2.mkdirSync(indexDir, { recursive: true });
+  }
+  fs2.writeFileSync(indexPath, JSON.stringify(index, null, 2), "utf-8");
+}
+function savePromptFile(basePath, category, name, content) {
+  const promptDir = path2.join(basePath, PROMPTS_BASE_PATH, category);
+  const promptPath = path2.join(promptDir, `${name}.md`);
+  if (!fs2.existsSync(promptDir)) {
+    fs2.mkdirSync(promptDir, { recursive: true });
+  }
+  fs2.writeFileSync(promptPath, content, "utf-8");
+  return `${PROMPTS_BASE_PATH}/${category}/${name}.md`;
+}
+function updateIndex(index, entry, isNew) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const existingIndex = index.prompts.findIndex((p) => p.id === entry.id);
+  if (existingIndex >= 0) {
+    index.prompts[existingIndex] = {
+      ...index.prompts[existingIndex],
+      ...entry,
+      updatedAt: now
+    };
+  } else {
+    index.prompts.push({
+      ...entry,
+      createdAt: now,
+      updatedAt: now,
+      usageCount: 0
+    });
+    index.categories[entry.category].count++;
+  }
+  index.stats.totalPrompts = index.prompts.length;
+  index.stats.recentlyAdded = entry.id;
+  index.lastUpdated = now;
+}
+function checkDuplicateEntry(index, name, category) {
+  const id = `${category}/${name}`;
+  return index.prompts.some((p) => p.id === id);
+}
+function handleSave(params) {
+  const { promptText, name, category, force = false } = params;
+  if (!promptText || promptText.trim() === "") {
+    throw new Error("\uC800\uC7A5\uD560 \uD504\uB86C\uD504\uD2B8(promptText)\uB294 \uD544\uC218\uC785\uB2C8\uB2E4.");
+  }
+  if (!name || name.trim() === "") {
+    throw new Error("\uD504\uB86C\uD504\uD2B8 \uC774\uB984(name)\uC740 \uD544\uC218\uC785\uB2C8\uB2E4.");
+  }
+  if (!category) {
+    throw new Error("\uCE74\uD14C\uACE0\uB9AC(category)\uB294 \uD544\uC218\uC785\uB2C8\uB2E4.");
+  }
+  const kebabCaseRegex = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
+  if (!kebabCaseRegex.test(name)) {
+    return {
+      success: false,
+      error: `\uC774\uB984\uC740 kebab-case \uD615\uC2DD\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4: ${name}`
+    };
+  }
+  try {
+    const basePath = process.cwd();
+    const index = loadIndex(basePath);
+    const isDuplicate = checkDuplicateEntry(index, name, category);
+    if (isDuplicate && !force) {
+      return {
+        success: false,
+        error: `\uC774\uBBF8 \uC874\uC7AC\uD558\uB294 \uD504\uB86C\uD504\uD2B8\uC785\uB2C8\uB2E4: ${category}/${name}. --force \uC635\uC158\uC73C\uB85C \uB36E\uC5B4\uC4F8 \uC218 \uC788\uC2B5\uB2C8\uB2E4.`
+      };
+    }
+    const metadata = extractMetadata(promptText);
+    const description = metadata?.description || "\uC7AC\uC0AC\uC6A9 \uAC00\uB2A5\uD55C \uD504\uB86C\uD504\uD2B8";
+    const variables = metadata?.variables || [];
+    const relativePath = savePromptFile(basePath, category, name, promptText);
+    const entryId = `${category}/${name}`;
+    updateIndex(
+      index,
+      {
+        id: entryId,
+        name,
+        category,
+        description,
+        path: relativePath,
+        variables
+      },
+      !isDuplicate
+    );
+    saveIndex(basePath, index);
+    return {
+      success: true,
+      path: relativePath,
+      promptId: entryId,
+      indexUpdated: true
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: `\uC800\uC7A5 \uC2E4\uD328: ${error instanceof Error ? error.message : "\uC54C \uC218 \uC5C6\uB294 \uC624\uB958"}`
+    };
+  }
+}
+function formatSaveResult(result) {
+  const lines = [];
+  if (result.success) {
+    lines.push("## \uC800\uC7A5 \uC644\uB8CC \u2705");
+    lines.push("");
+    lines.push(`- **\uACBD\uB85C**: \`${result.path}\``);
+    lines.push(`- **\uD504\uB86C\uD504\uD2B8 ID**: \`${result.promptId}\``);
+    lines.push(`- **\uC778\uB371\uC2A4 \uAC31\uC2E0**: ${result.indexUpdated ? "\u2705" : "\u274C"}`);
+    lines.push("");
+    lines.push("### \uC0AC\uC6A9 \uBC29\uBC95");
+    lines.push("");
+    lines.push("```");
+    lines.push(`\uC774 \uD504\uB86C\uD504\uD2B8\uB97C \uC0AC\uC6A9\uD558\uC5EC {{VARIABLE}}\uC5D0 \uB300\uD574...`);
+    lines.push("```");
+    lines.push("");
+    lines.push("\uB610\uB294 \uC9C1\uC811 \uCC38\uC870:");
+    lines.push("");
+    lines.push("```");
+    lines.push(`${result.path}`);
+    lines.push("```");
+  } else {
+    lines.push("## \uC800\uC7A5 \uC2E4\uD328 \u274C");
+    lines.push("");
+    lines.push(`**\uC624\uB958**: ${result.error}`);
+    lines.push("");
+    lines.push("### \uD574\uACB0 \uBC29\uBC95");
+    lines.push("");
+    if (result.error?.includes("kebab-case")) {
+      lines.push("- \uC774\uB984\uC744 kebab-case \uD615\uC2DD\uC73C\uB85C \uBCC0\uACBD\uD558\uC138\uC694 (\uC608: my-prompt)");
+    } else if (result.error?.includes("\uC774\uBBF8 \uC874\uC7AC")) {
+      lines.push("- \uB2E4\uB978 \uC774\uB984\uC744 \uC0AC\uC6A9\uD558\uAC70\uB098");
+      lines.push("- `--force` \uC635\uC158\uC73C\uB85C \uB36E\uC5B4\uC4F0\uAE30: `/ax-prompt save --force`");
+    } else {
+      lines.push("- \uC624\uB958 \uBA54\uC2DC\uC9C0\uB97C \uD655\uC778\uD558\uACE0 \uC218\uC815\uD558\uC138\uC694");
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/tools/template.ts
+import fetch from "node-fetch";
+import fs3 from "fs-extra";
+import path3 from "path";
+var TEMPLATE_REGISTRY_URL = process.env.AXIS_TEMPLATE_URL || "https://ds.minu.best/templates";
+async function fetchTemplateIndex() {
+  const url = `${TEMPLATE_REGISTRY_URL}/index.json`;
+  const res = await fetch(url);
+  if (!res.ok) {
+    throw new Error(`\uD15C\uD50C\uB9BF \uC778\uB371\uC2A4\uB97C \uAC00\uC838\uC62C \uC218 \uC5C6\uC2B5\uB2C8\uB2E4 (${res.status}): ${url}`);
+  }
+  return await res.json();
+}
+async function fetchTemplateDetail(slug) {
+  const url = `${TEMPLATE_REGISTRY_URL}/${slug}.json`;
+  const res = await fetch(url);
+  if (!res.ok) {
+    throw new Error(`'${slug}' \uD15C\uD50C\uB9BF\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4 (${res.status}): ${url}`);
+  }
+  return await res.json();
+}
+async function handleListTemplates(params) {
+  const index = await fetchTemplateIndex();
+  let templates = index.templates;
+  if (params.category) {
+    templates = templates.filter((t) => t.category === params.category);
+  }
+  return {
+    total: templates.length,
+    templates: templates.map((t) => ({
+      name: t.name,
+      slug: t.slug,
+      description: t.description,
+      category: t.category
+    }))
+  };
+}
+async function handleGetTemplate(params) {
+  const detail = await fetchTemplateDetail(params.name);
+  return {
+    name: detail.name,
+    slug: detail.slug,
+    description: detail.description,
+    category: detail.category,
+    version: detail.version,
+    features: detail.features,
+    dependencies: detail.dependencies || {},
+    devDependencies: detail.devDependencies || {},
+    files: detail.files.map((f) => f.path)
+  };
+}
+async function handleApplyTemplate(params) {
+  const detail = await fetchTemplateDetail(params.name);
+  const baseDir = path3.resolve(params.targetDir);
+  const files = [];
+  for (const file of detail.files) {
+    const dest = path3.join(baseDir, file.path);
+    const exists = await fs3.pathExists(dest);
+    if (!params.dryRun) {
+      await fs3.ensureDir(path3.dirname(dest));
+      await fs3.writeFile(dest, file.content);
+    }
+    files.push({
+      path: file.path,
+      action: exists ? "overwritten" : "created"
+    });
+  }
+  if (!params.dryRun && detail.postInstall?.length) {
+    for (const patch of detail.postInstall) {
+      const target = path3.join(baseDir, patch.file);
+      if (!await fs3.pathExists(target)) continue;
+      if (patch.type === "replace" && patch.search && patch.value) {
+        const content = await fs3.readFile(target, "utf-8");
+        await fs3.writeFile(target, content.replace(patch.search, patch.value));
+      } else if (patch.type === "append" && patch.value) {
+        await fs3.appendFile(target, patch.value);
+      } else if (patch.type === "prepend" && patch.value) {
+        const content = await fs3.readFile(target, "utf-8");
+        await fs3.writeFile(target, patch.value + content);
+      } else if (patch.type === "json-merge" && patch.merge) {
+        const content = await fs3.readJSON(target);
+        await fs3.writeJSON(target, { ...content, ...patch.merge }, { spaces: 2 });
+      }
+    }
+  }
+  return {
+    success: true,
+    templateName: detail.name,
+    files,
+    dependencies: detail.dependencies || {},
+    devDependencies: detail.devDependencies || {},
+    dryRun: !!params.dryRun
+  };
+}
+async function handleDiffTemplate(params) {
+  const detail = await fetchTemplateDetail(params.name);
+  const baseDir = path3.resolve(params.targetDir || ".");
+  const entries = [];
+  for (const file of detail.files) {
+    const localPath = path3.join(baseDir, file.path);
+    if (!await fs3.pathExists(localPath)) {
+      entries.push({ path: file.path, status: "added" });
+      continue;
+    }
+    const localContent = await fs3.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
+      });
+    }
+  }
+  const summary = {
+    added: entries.filter((e) => e.status === "added").length,
+    modified: entries.filter((e) => e.status === "modified").length,
+    unchanged: entries.filter((e) => e.status === "unchanged").length,
+    extra: entries.filter((e) => e.status === "extra").length
+  };
+  return { templateName: detail.name, entries, summary };
+}
+async function handleCheckProject(params) {
+  const baseDir = path3.resolve(params.targetDir || ".");
+  const results = [];
+  const configExists = await fs3.pathExists(path3.join(baseDir, "axis.config.json"));
+  results.push({
+    name: "axis.config.json",
+    severity: configExists ? "pass" : "fail",
+    message: configExists ? "axis.config.json \uD30C\uC77C\uC774 \uC874\uC7AC\uD569\uB2C8\uB2E4" : "axis.config.json \uD30C\uC77C\uC774 \uC5C6\uC2B5\uB2C8\uB2E4 \u2192 'axis init'\uC744 \uC2E4\uD589\uD558\uC138\uC694"
+  });
+  const twTs = path3.join(baseDir, "tailwind.config.ts");
+  const twJs = path3.join(baseDir, "tailwind.config.js");
+  if (await fs3.pathExists(twTs)) {
+    const content = await fs3.readFile(twTs, "utf-8");
+    const hasTokens = content.includes("--background") || content.includes("hsl(var(");
+    results.push({
+      name: "tailwind.config",
+      severity: hasTokens ? "pass" : "warn",
+      message: hasTokens ? "tailwind.config.ts\uC5D0 AXIS \uD1A0\uD070\uC774 \uC124\uC815\uB418\uC5B4 \uC788\uC2B5\uB2C8\uB2E4" : "tailwind.config.ts\uC5D0 AXIS \uD1A0\uD070 \uC124\uC815\uC774 \uC5C6\uC2B5\uB2C8\uB2E4"
+    });
+  } else if (await fs3.pathExists(twJs)) {
+    results.push({
+      name: "tailwind.config",
+      severity: "warn",
+      message: "tailwind.config.js \uC874\uC7AC (TypeScript \uAD8C\uC7A5)"
+    });
+  } else {
+    results.push({
+      name: "tailwind.config",
+      severity: "fail",
+      message: "tailwind.config \uD30C\uC77C\uC774 \uC5C6\uC2B5\uB2C8\uB2E4"
+    });
+  }
+  const cssCandidates = [
+    "globals.css",
+    "app/globals.css",
+    "src/app/globals.css",
+    "src/globals.css",
+    "styles/globals.css"
+  ];
+  let cssFound = false;
+  for (const candidate of cssCandidates) {
+    const fullPath = path3.join(baseDir, candidate);
+    if (await fs3.pathExists(fullPath)) {
+      const content = await fs3.readFile(fullPath, "utf-8");
+      const hasTokens = content.includes("--background") && content.includes("--primary");
+      results.push({
+        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`
+      });
+      cssFound = true;
+      break;
+    }
+  }
+  if (!cssFound) {
+    results.push({
+      name: "globals.css",
+      severity: "fail",
+      message: "globals.css \uD30C\uC77C\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4"
+    });
+  }
+  const utilsCandidates = [
+    "lib/utils.ts",
+    "src/lib/utils.ts",
+    "components/ui/utils.ts",
+    "src/components/ui/utils.ts",
+    "utils.ts"
+  ];
+  let utilsFound = false;
+  for (const candidate of utilsCandidates) {
+    const fullPath = path3.join(baseDir, candidate);
+    if (await fs3.pathExists(fullPath)) {
+      const content = await fs3.readFile(fullPath, "utf-8");
+      const hasCn = content.includes("function cn");
+      results.push({
+        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`
+      });
+      utilsFound = true;
+      break;
+    }
+  }
+  if (!utilsFound) {
+    results.push({
+      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)"
+    });
+  }
+  const pkgPath = path3.join(baseDir, "package.json");
+  if (await fs3.pathExists(pkgPath)) {
+    const pkg = await fs3.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) {
+      results.push({
+        name: "dependencies",
+        severity: "fail",
+        message: `\uD544\uC218 \uC758\uC874\uC131 \uB204\uB77D: ${missingRequired.join(", ")}`
+      });
+    } else if (missingRecommended.length > 0) {
+      results.push({
+        name: "dependencies",
+        severity: "warn",
+        message: `\uAD8C\uC7A5 \uC758\uC874\uC131 \uB204\uB77D: ${missingRecommended.join(", ")}`
+      });
+    } else {
+      results.push({
+        name: "dependencies",
+        severity: "pass",
+        message: "\uD544\uC218 \uBC0F \uAD8C\uC7A5 \uC758\uC874\uC131\uC774 \uBAA8\uB450 \uC124\uCE58\uB418\uC5B4 \uC788\uC2B5\uB2C8\uB2E4"
+      });
+    }
+  } else {
+    results.push({
+      name: "dependencies",
+      severity: "fail",
+      message: "package.json \uD30C\uC77C\uC774 \uC5C6\uC2B5\uB2C8\uB2E4"
+    });
+  }
+  const summary = {
+    pass: results.filter((r) => r.severity === "pass").length,
+    warn: results.filter((r) => r.severity === "warn").length,
+    fail: results.filter((r) => r.severity === "fail").length
+  };
+  return { results, summary };
+}
+function formatListTemplatesResult(result) {
+  const lines = [`## AXIS \uD15C\uD50C\uB9BF \uBAA9\uB85D (${result.total}\uAC1C)
+`];
+  if (result.templates.length === 0) {
+    lines.push("\uB4F1\uB85D\uB41C \uD15C\uD50C\uB9BF\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.");
+    return lines.join("\n");
+  }
+  lines.push("| \uC774\uB984 | \uC124\uBA85 | \uCE74\uD14C\uACE0\uB9AC |");
+  lines.push("|------|------|----------|");
+  for (const t of result.templates) {
+    lines.push(`| ${t.name} | ${t.description} | ${t.category} |`);
+  }
+  return lines.join("\n");
+}
+function formatGetTemplateResult(result) {
+  const lines = [
+    `## ${result.name}`,
+    "",
+    `- **\uC124\uBA85**: ${result.description}`,
+    `- **\uCE74\uD14C\uACE0\uB9AC**: ${result.category}`,
+    `- **\uBC84\uC804**: ${result.version}`
+  ];
+  if (result.features.length > 0) {
+    lines.push("", "### Features", "");
+    for (const f of result.features) {
+      lines.push(`- ${f}`);
+    }
+  }
+  const deps = Object.entries(result.dependencies);
+  const devDeps = Object.entries(result.devDependencies);
+  if (deps.length > 0 || devDeps.length > 0) {
+    lines.push("", "### \uC758\uC874\uC131", "");
+    for (const [k, v] of deps) {
+      lines.push(`- ${k}@${v}`);
+    }
+    for (const [k, v] of devDeps) {
+      lines.push(`- ${k}@${v} (dev)`);
+    }
+  }
+  if (result.files.length > 0) {
+    lines.push("", "### \uD30C\uC77C \uBAA9\uB85D", "");
+    for (const f of result.files) {
+      lines.push(`- ${f}`);
+    }
+  }
+  return lines.join("\n");
+}
+function formatApplyTemplateResult(result) {
+  const mode = result.dryRun ? " (\uBBF8\uB9AC\uBCF4\uAE30)" : "";
+  const lines = [`## \uD15C\uD50C\uB9BF \uC801\uC6A9 \uACB0\uACFC${mode}
+`];
+  lines.push(`\uD15C\uD50C\uB9BF: **${result.templateName}**
+`);
+  if (result.files.length > 0) {
+    lines.push("### \uD30C\uC77C", "");
+    for (const f of result.files) {
+      const icon = f.action === "created" ? "+" : "~";
+      lines.push(`- ${icon} ${f.path} (${f.action === "created" ? "\uC0DD\uC131" : "\uB36E\uC5B4\uC4F0\uAE30"})`);
+    }
+  }
+  const deps = Object.entries(result.dependencies);
+  const devDeps = Object.entries(result.devDependencies);
+  if (deps.length > 0 || devDeps.length > 0) {
+    lines.push("", "### \uD544\uC694\uD55C \uC758\uC874\uC131", "");
+    if (deps.length > 0) {
+      lines.push(`\`pnpm add ${deps.map(([k, v]) => `${k}@${v}`).join(" ")}\``);
+    }
+    if (devDeps.length > 0) {
+      lines.push(`\`pnpm add -D ${devDeps.map(([k, v]) => `${k}@${v}`).join(" ")}\``);
+    }
+  }
+  return lines.join("\n");
+}
+function formatDiffTemplateResult(result) {
+  const lines = [`## '${result.templateName}' \uD15C\uD50C\uB9BF diff \uACB0\uACFC
+`];
+  const statusLabel = {
+    added: "+ \uCD94\uAC00 \uD544\uC694",
+    modified: "~ \uBCC0\uACBD\uB428",
+    unchanged: "= \uB3D9\uC77C",
+    extra: "? \uB85C\uCEEC \uC804\uC6A9"
+  };
+  for (const entry of result.entries) {
+    lines.push(`- ${statusLabel[entry.status]}  ${entry.path}`);
+  }
+  const s = result.summary;
+  lines.push(
+    "",
+    `**\uC694\uC57D**: \uCD94\uAC00 \uD544\uC694 ${s.added} | \uBCC0\uACBD\uB428 ${s.modified} | \uB3D9\uC77C ${s.unchanged}${s.extra > 0 ? ` | \uB85C\uCEEC \uC804\uC6A9 ${s.extra}` : ""}`
+  );
+  return lines.join("\n");
+}
+function formatCheckProjectResult(result) {
+  const lines = ["## AXIS \uD504\uB85C\uC81D\uD2B8 \uAC80\uC99D \uACB0\uACFC\n"];
+  const icon = {
+    pass: "PASS",
+    warn: "WARN",
+    fail: "FAIL"
+  };
+  for (const r of result.results) {
+    lines.push(`- [${icon[r.severity]}] ${r.message}`);
+  }
+  const s = result.summary;
+  lines.push("", `**\uACB0\uACFC**: ${s.pass} pass / ${s.warn} warn / ${s.fail} fail`);
+  return lines.join("\n");
+}
+
+// src/index.ts
+var server = new McpServer({
+  name: "axis-design-system",
+  version: "0.1.0"
+});
+var ComponentCategorySchema = z.enum(["core", "agentic", "form", "layout"]).optional().describe("\uCEF4\uD3EC\uB10C\uD2B8 \uCE74\uD14C\uACE0\uB9AC \uD544\uD130");
+var TokenCategorySchema = z.enum(["color", "typography", "spacing", "radius", "shadow", "animation"]).optional().describe("\uD1A0\uD070 \uCE74\uD14C\uACE0\uB9AC \uD544\uD130");
+server.tool(
+  "axis.search_components",
+  "AXIS \uB514\uC790\uC778 \uC2DC\uC2A4\uD15C\uC5D0\uC11C \uCEF4\uD3EC\uB10C\uD2B8\uB97C \uAC80\uC0C9\uD569\uB2C8\uB2E4.",
+  {
+    query: z.string().describe("\uAC80\uC0C9\uC5B4 (\uCEF4\uD3EC\uB10C\uD2B8 \uC774\uB984, \uC124\uBA85 \uB4F1)"),
+    category: ComponentCategorySchema
+  },
+  async ({ query, category }) => {
+    try {
+      const result = handleSearchComponents({
+        query,
+        category
+      });
+      const formatted = formatSearchResult(result);
+      return {
+        content: [
+          {
+            type: "text",
+            text: formatted
+          }
+        ]
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "\uC54C \uC218 \uC5C6\uB294 \uC624\uB958";
+      return {
+        content: [
+          {
+            type: "text",
+            text: `\uC624\uB958: ${message}`
+          }
+        ],
+        isError: true
+      };
+    }
+  }
+);
+server.tool(
+  "axis.get_component",
+  "AXIS \uB514\uC790\uC778 \uC2DC\uC2A4\uD15C \uCEF4\uD3EC\uB10C\uD2B8\uC758 \uC0C1\uC138 \uC815\uBCF4\uB97C \uC870\uD68C\uD569\uB2C8\uB2E4.",
+  {
+    name: z.string().describe("\uCEF4\uD3EC\uB10C\uD2B8 \uC774\uB984 (\uC608: button, input)")
+  },
+  async ({ name }) => {
+    try {
+      const component = handleGetComponent({ name });
+      const formatted = formatComponentDetail(component);
+      return {
+        content: [
+          {
+            type: "text",
+            text: formatted
+          }
+        ]
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "\uC54C \uC218 \uC5C6\uB294 \uC624\uB958";
+      return {
+        content: [
+          {
+            type: "text",
+            text: `\uC624\uB958: ${message}`
+          }
+        ],
+        isError: true
+      };
+    }
+  }
+);
+server.tool(
+  "axis.list_components",
+  "AXIS \uB514\uC790\uC778 \uC2DC\uC2A4\uD15C\uC758 \uBAA8\uB4E0 \uCEF4\uD3EC\uB10C\uD2B8 \uBAA9\uB85D\uC744 \uC870\uD68C\uD569\uB2C8\uB2E4.",
+  {
+    category: ComponentCategorySchema
+  },
+  async ({ category }) => {
+    try {
+      const result = handleListComponents({
+        category
+      });
+      const formatted = formatComponentList(result);
+      return {
+        content: [
+          {
+            type: "text",
+            text: formatted
+          }
+        ]
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "\uC54C \uC218 \uC5C6\uB294 \uC624\uB958";
+      return {
+        content: [
+          {
+            type: "text",
+            text: `\uC624\uB958: ${message}`
+          }
+        ],
+        isError: true
+      };
+    }
+  }
+);
+server.tool(
+  "axis.list_tokens",
+  "AXIS \uB514\uC790\uC778 \uC2DC\uC2A4\uD15C\uC758 \uB514\uC790\uC778 \uD1A0\uD070 \uBAA9\uB85D\uC744 \uC870\uD68C\uD569\uB2C8\uB2E4.",
+  {
+    category: TokenCategorySchema
+  },
+  async ({ category }) => {
+    try {
+      const result = handleListTokens({
+        category
+      });
+      const formatted = formatTokenList(result);
+      return {
+        content: [
+          {
+            type: "text",
+            text: formatted
+          }
+        ]
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "\uC54C \uC218 \uC5C6\uB294 \uC624\uB958";
+      return {
+        content: [
+          {
+            type: "text",
+            text: `\uC624\uB958: ${message}`
+          }
+        ],
+        isError: true
+      };
+    }
+  }
+);
+server.tool(
+  "axis.get_token",
+  "AXIS \uB514\uC790\uC778 \uC2DC\uC2A4\uD15C \uD1A0\uD070\uC758 \uC0C1\uC138 \uC815\uBCF4\uB97C \uC870\uD68C\uD569\uB2C8\uB2E4.",
+  {
+    path: z.string().describe("\uD1A0\uD070 \uACBD\uB85C (\uC608: colors.primary, spacing.4)")
+  },
+  async ({ path: path4 }) => {
+    try {
+      const token = handleGetToken({ path: path4 });
+      const formatted = formatTokenDetail(token);
+      return {
+        content: [
+          {
+            type: "text",
+            text: formatted
+          }
+        ]
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "\uC54C \uC218 \uC5C6\uB294 \uC624\uB958";
+      return {
+        content: [
+          {
+            type: "text",
+            text: `\uC624\uB958: ${message}`
+          }
+        ],
+        isError: true
+      };
+    }
+  }
+);
+server.tool(
+  "axis.install_component",
+  "AXIS \uB514\uC790\uC778 \uC2DC\uC2A4\uD15C \uCEF4\uD3EC\uB10C\uD2B8\uB97C \uD504\uB85C\uC81D\uD2B8\uC5D0 \uC124\uCE58\uD569\uB2C8\uB2E4.",
+  {
+    name: z.string().describe("\uC124\uCE58\uD560 \uCEF4\uD3EC\uB10C\uD2B8 \uC774\uB984"),
+    targetDir: z.string().describe("\uC124\uCE58 \uB300\uC0C1 \uB514\uB809\uD1A0\uB9AC \uACBD\uB85C")
+  },
+  async ({ name, targetDir }) => {
+    try {
+      const result = handleInstallComponent({ name, targetDir });
+      const formatted = formatInstallResult(result);
+      return {
+        content: [
+          {
+            type: "text",
+            text: formatted
+          }
+        ],
+        isError: !result.success
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "\uC54C \uC218 \uC5C6\uB294 \uC624\uB958";
+      return {
+        content: [
+          {
+            type: "text",
+            text: `\uC624\uB958: ${message}`
+          }
+        ],
+        isError: true
+      };
+    }
+  }
+);
+var PromptCategorySchema = z.enum(["planning", "quality", "documentation", "workflow"]).optional().describe("\uD504\uB86C\uD504\uD2B8 \uCE74\uD14C\uACE0\uB9AC");
+server.tool(
+  "axis.prompt.detect",
+  "\uC138\uC158 \uCEE8\uD14D\uC2A4\uD2B8\uC5D0\uC11C \uC7AC\uC0AC\uC6A9 \uAC00\uB2A5\uD55C \uD504\uB86C\uD504\uD2B8 \uD6C4\uBCF4\uB97C \uD0D0\uC9C0\uD569\uB2C8\uB2E4.",
+  {
+    context: z.string().describe("\uC138\uC158 \uCEE8\uD14D\uC2A4\uD2B8 \uD14D\uC2A4\uD2B8"),
+    minScore: z.number().optional().describe("\uCD5C\uC18C \uC810\uC218 \uAE30\uC900 (\uAE30\uBCF8: 70)"),
+    maxCandidates: z.number().optional().describe("\uCD5C\uB300 \uD6C4\uBCF4 \uC218 (\uAE30\uBCF8: 5)")
+  },
+  async ({ context, minScore, maxCandidates }) => {
+    try {
+      const result = handleDetect({ context, minScore, maxCandidates });
+      const formatted = formatDetectResult(result);
+      return {
+        content: [
+          {
+            type: "text",
+            text: formatted
+          }
+        ]
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "\uC54C \uC218 \uC5C6\uB294 \uC624\uB958";
+      return {
+        content: [
+          {
+            type: "text",
+            text: `\uC624\uB958: ${message}`
+          }
+        ],
+        isError: true
+      };
+    }
+  }
+);
+server.tool(
+  "axis.prompt.analyze",
+  "\uD14D\uC2A4\uD2B8\uC758 \uC7AC\uC0AC\uC6A9 \uAC00\uB2A5\uC131\uC744 \uBD84\uC11D\uD558\uACE0 \uAD6C\uC870\uB97C \uD30C\uC545\uD569\uB2C8\uB2E4.",
+  {
+    text: z.string().describe("\uBD84\uC11D\uD560 \uD14D\uC2A4\uD2B8")
+  },
+  async ({ text }) => {
+    try {
+      const result = handleAnalyze({ text });
+      const formatted = formatAnalyzeResult(result);
+      return {
+        content: [
+          {
+            type: "text",
+            text: formatted
+          }
+        ]
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "\uC54C \uC218 \uC5C6\uB294 \uC624\uB958";
+      return {
+        content: [
+          {
+            type: "text",
+            text: `\uC624\uB958: ${message}`
+          }
+        ],
+        isError: true
+      };
+    }
+  }
+);
+server.tool(
+  "axis.prompt.refine",
+  "\uD504\uB85C\uC81D\uD2B8 \uC885\uC18D\uC131\uC744 \uC81C\uAC70\uD558\uACE0 \uBC94\uC6A9 \uD504\uB86C\uD504\uD2B8\uB85C \uC815\uC81C\uD569\uB2C8\uB2E4.",
+  {
+    text: z.string().describe("\uC815\uC81C\uD560 \uD14D\uC2A4\uD2B8"),
+    name: z.string().optional().describe("\uD504\uB86C\uD504\uD2B8 \uC774\uB984 (kebab-case)"),
+    category: PromptCategorySchema
+  },
+  async ({ text, name, category }) => {
+    try {
+      const result = handleRefine({
+        text,
+        name,
+        category
+      });
+      const formatted = formatRefineResult(result);
+      return {
+        content: [
+          {
+            type: "text",
+            text: formatted
+          }
+        ]
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "\uC54C \uC218 \uC5C6\uB294 \uC624\uB958";
+      return {
+        content: [
+          {
+            type: "text",
+            text: `\uC624\uB958: ${message}`
+          }
+        ],
+        isError: true
+      };
+    }
+  }
+);
+server.tool(
+  "axis.prompt.validate",
+  "\uC815\uC81C\uB41C \uD504\uB86C\uD504\uD2B8\uC758 \uD488\uC9C8\uC744 \uAC80\uC99D\uD569\uB2C8\uB2E4.",
+  {
+    promptText: z.string().describe("\uAC80\uC99D\uD560 \uD504\uB86C\uD504\uD2B8 \uD14D\uC2A4\uD2B8 (\uD504\uB860\uD2B8\uB9E4\uD130 \uD3EC\uD568)"),
+    checkDuplicate: z.boolean().optional().describe("\uC911\uBCF5 \uAC80\uC0AC \uD65C\uC131\uD654 (\uAE30\uBCF8: true)")
+  },
+  async ({ promptText, checkDuplicate: checkDuplicate2 }) => {
+    try {
+      const result = handleValidate({ promptText, checkDuplicate: checkDuplicate2 });
+      const formatted = formatValidateResult(result);
+      return {
+        content: [
+          {
+            type: "text",
+            text: formatted
+          }
+        ]
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "\uC54C \uC218 \uC5C6\uB294 \uC624\uB958";
+      return {
+        content: [
+          {
+            type: "text",
+            text: `\uC624\uB958: ${message}`
+          }
+        ],
+        isError: true
+      };
+    }
+  }
+);
+server.tool(
+  "axis.prompt.save",
+  "\uAC80\uC99D\uB41C \uD504\uB86C\uD504\uD2B8\uB97C \uD30C\uC77C\uB85C \uC800\uC7A5\uD558\uACE0 \uC778\uB371\uC2A4\uB97C \uAC31\uC2E0\uD569\uB2C8\uB2E4.",
+  {
+    promptText: z.string().describe("\uC800\uC7A5\uD560 \uD504\uB86C\uD504\uD2B8 \uD14D\uC2A4\uD2B8 (\uD504\uB860\uD2B8\uB9E4\uD130 \uD3EC\uD568)"),
+    name: z.string().describe("\uD504\uB86C\uD504\uD2B8 \uC774\uB984 (kebab-case)"),
+    category: z.enum(["planning", "quality", "documentation", "workflow"]).describe("\uCE74\uD14C\uACE0\uB9AC"),
+    force: z.boolean().optional().describe("\uAC15\uC81C \uC800\uC7A5 (\uC911\uBCF5 \uBB34\uC2DC, \uAE30\uBCF8: false)")
+  },
+  async ({ promptText, name, category, force }) => {
+    try {
+      const result = handleSave({
+        promptText,
+        name,
+        category,
+        force
+      });
+      const formatted = formatSaveResult(result);
+      return {
+        content: [
+          {
+            type: "text",
+            text: formatted
+          }
+        ],
+        isError: !result.success
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "\uC54C \uC218 \uC5C6\uB294 \uC624\uB958";
+      return {
+        content: [
+          {
+            type: "text",
+            text: `\uC624\uB958: ${message}`
+          }
+        ],
+        isError: true
+      };
+    }
+  }
+);
+server.tool(
+  "axis.list_templates",
+  "AXIS \uB514\uC790\uC778 \uC2DC\uC2A4\uD15C\uC758 \uD15C\uD50C\uB9BF \uBAA9\uB85D\uC744 \uC870\uD68C\uD569\uB2C8\uB2E4.",
+  {
+    category: z.string().optional().describe("\uD15C\uD50C\uB9BF \uCE74\uD14C\uACE0\uB9AC \uD544\uD130")
+  },
+  async ({ category }) => {
+    try {
+      const result = await handleListTemplates({ category });
+      const formatted = formatListTemplatesResult(result);
+      return {
+        content: [
+          {
+            type: "text",
+            text: formatted
+          }
+        ]
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "\uC54C \uC218 \uC5C6\uB294 \uC624\uB958";
+      return {
+        content: [
+          {
+            type: "text",
+            text: `\uC624\uB958: ${message}`
+          }
+        ],
+        isError: true
+      };
+    }
+  }
+);
+server.tool(
+  "axis.get_template",
+  "AXIS \uB514\uC790\uC778 \uC2DC\uC2A4\uD15C \uD15C\uD50C\uB9BF\uC758 \uC0C1\uC138 \uC815\uBCF4\uB97C \uC870\uD68C\uD569\uB2C8\uB2E4.",
+  {
+    name: z.string().describe("\uD15C\uD50C\uB9BF \uC774\uB984 (slug)")
+  },
+  async ({ name }) => {
+    try {
+      const result = await handleGetTemplate({ name });
+      const formatted = formatGetTemplateResult(result);
+      return {
+        content: [
+          {
+            type: "text",
+            text: formatted
+          }
+        ]
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "\uC54C \uC218 \uC5C6\uB294 \uC624\uB958";
+      return {
+        content: [
+          {
+            type: "text",
+            text: `\uC624\uB958: ${message}`
+          }
+        ],
+        isError: true
+      };
+    }
+  }
+);
+server.tool(
+  "axis.apply_template",
+  "AXIS \uB514\uC790\uC778 \uC2DC\uC2A4\uD15C \uD15C\uD50C\uB9BF\uC744 \uD504\uB85C\uC81D\uD2B8\uC5D0 \uC801\uC6A9\uD569\uB2C8\uB2E4.",
+  {
+    name: z.string().describe("\uD15C\uD50C\uB9BF \uC774\uB984 (slug)"),
+    targetDir: z.string().describe("\uC801\uC6A9 \uB300\uC0C1 \uB514\uB809\uD1A0\uB9AC \uACBD\uB85C"),
+    dryRun: z.boolean().optional().describe("\uBBF8\uB9AC\uBCF4\uAE30 \uBAA8\uB4DC (\uD30C\uC77C \uBBF8\uC0DD\uC131, \uAE30\uBCF8: false)")
+  },
+  async ({ name, targetDir, dryRun }) => {
+    try {
+      const result = await handleApplyTemplate({ name, targetDir, dryRun });
+      const formatted = formatApplyTemplateResult(result);
+      return {
+        content: [
+          {
+            type: "text",
+            text: formatted
+          }
+        ],
+        isError: !result.success
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "\uC54C \uC218 \uC5C6\uB294 \uC624\uB958";
+      return {
+        content: [
+          {
+            type: "text",
+            text: `\uC624\uB958: ${message}`
+          }
+        ],
+        isError: true
+      };
+    }
+  }
+);
+server.tool(
+  "axis.diff_template",
+  "\uB85C\uCEEC \uD504\uB85C\uC81D\uD2B8\uC640 \uC6D0\uACA9 \uD15C\uD50C\uB9BF\uC758 \uD30C\uC77C \uCC28\uC774\uB97C \uBE44\uAD50\uD569\uB2C8\uB2E4.",
+  {
+    name: z.string().describe("\uD15C\uD50C\uB9BF \uC774\uB984 (slug)"),
+    targetDir: z.string().optional().describe("\uBE44\uAD50 \uB300\uC0C1 \uB514\uB809\uD1A0\uB9AC (\uAE30\uBCF8: \uD604\uC7AC \uB514\uB809\uD1A0\uB9AC)")
+  },
+  async ({ name, targetDir }) => {
+    try {
+      const result = await handleDiffTemplate({ name, targetDir });
+      const formatted = formatDiffTemplateResult(result);
+      return {
+        content: [
+          {
+            type: "text",
+            text: formatted
+          }
+        ]
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "\uC54C \uC218 \uC5C6\uB294 \uC624\uB958";
+      return {
+        content: [
+          {
+            type: "text",
+            text: `\uC624\uB958: ${message}`
+          }
+        ],
+        isError: true
+      };
+    }
+  }
+);
+server.tool(
+  "axis.check_project",
+  "\uD504\uB85C\uC81D\uD2B8\uC758 AXIS \uB514\uC790\uC778 \uC2DC\uC2A4\uD15C \uC124\uC815 \uC0C1\uD0DC\uB97C \uAC80\uC99D\uD569\uB2C8\uB2E4.",
+  {
+    targetDir: z.string().optional().describe("\uAC80\uC99D \uB300\uC0C1 \uB514\uB809\uD1A0\uB9AC (\uAE30\uBCF8: \uD604\uC7AC \uB514\uB809\uD1A0\uB9AC)")
+  },
+  async ({ targetDir }) => {
+    try {
+      const result = await handleCheckProject({ targetDir });
+      const formatted = formatCheckProjectResult(result);
+      return {
+        content: [
+          {
+            type: "text",
+            text: formatted
+          }
+        ]
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "\uC54C \uC218 \uC5C6\uB294 \uC624\uB958";
+      return {
+        content: [
+          {
+            type: "text",
+            text: `\uC624\uB958: ${message}`
+          }
+        ],
+        isError: true
+      };
+    }
+  }
+);
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  process.on("SIGINT", async () => {
+    await server.close();
+    process.exit(0);
+  });
+  process.on("SIGTERM", async () => {
+    await server.close();
+    process.exit(0);
+  });
+}
+main().catch((error) => {
+  console.error("MCP \uC11C\uBC84 \uC2DC\uC791 \uC2E4\uD328:", error);
+  process.exit(1);
+});