@fragments-sdk/mcp 0.5.8 → 0.5.10

package/dist/{chunk-SZ63UDGU.js → chunk-XMNCAB2A.js}

@@ -1,8 +1,3 @@
-import {
-  ComponentGraphEngine,
-  deserializeGraph
-} from "./chunk-IEJ7ZYTZ.js";
-
 // src/server.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
@@ -12,7 +7,7 @@ import {
 } from "@modelcontextprotocol/sdk/types.js";
 import { readFile } from "fs/promises";
 import { existsSync as existsSync2 } from "fs";
-import { readFileSync as readFileSync2 } from "fs";
+import { readFileSync as readFileSync3 } from "fs";
 import { join as join2 } from "path";
 import { fileURLToPath } from "url";
 
@@ -89,546 +84,9 @@ var DEFAULTS = {
   port: 6006
 };
 
-// ../context/dist/chunk-2UQY4VNM.js
-var PLACEHOLDER_PATTERNS = [
-  /^\w+ component is needed$/i,
-  /^Alternative component is more appropriate$/i,
-  /^Use \w+ when you need/i
-];
-function filterPlaceholders(items) {
-  if (!items) return [];
-  return items.filter(
-    (item) => !PLACEHOLDER_PATTERNS.some((pattern) => pattern.test(item.trim()))
-  );
-}
-function generateContext(fragments, options = {}, blocks) {
-  const format = options.format ?? "markdown";
-  const compact = options.compact ?? false;
-  const include = {
-    props: options.include?.props ?? true,
-    variants: options.include?.variants ?? true,
-    usage: options.include?.usage ?? true,
-    relations: options.include?.relations ?? false,
-    code: options.include?.code ?? false
-  };
-  const sorted = [...fragments].sort((a, b) => {
-    const catCompare = a.meta.category.localeCompare(b.meta.category);
-    if (catCompare !== 0) return catCompare;
-    return a.meta.name.localeCompare(b.meta.name);
-  });
-  if (format === "json") {
-    return generateJsonContext(sorted, include, compact, blocks);
-  }
-  return generateMarkdownContext(sorted, include, compact, blocks);
-}
-function generateMarkdownContext(fragments, include, compact, blocks) {
-  const lines = [];
-  lines.push("# Design System Reference");
-  lines.push("");
-  lines.push("## Quick Reference");
-  lines.push("");
-  lines.push("| Component | Category | Use For |");
-  lines.push("|-----------|----------|---------|");
-  for (const fragment of fragments) {
-    const filteredWhen = filterPlaceholders(fragment.usage.when);
-    const useFor = filteredWhen.slice(0, 2).join(", ") || fragment.meta.description;
-    lines.push(`| ${fragment.meta.name} | ${fragment.meta.category} | ${truncate(useFor, 50)} |`);
-  }
-  lines.push("");
-  if (compact) {
-    const content2 = lines.join("\n");
-    return { content: content2, tokenEstimate: estimateTokens(content2) };
-  }
-  lines.push("## Components");
-  lines.push("");
-  for (const fragment of fragments) {
-    lines.push(`### ${fragment.meta.name}`);
-    lines.push("");
-    const statusParts = [`**Category:** ${fragment.meta.category}`];
-    if (fragment.meta.status) {
-      statusParts.push(`**Status:** ${fragment.meta.status}`);
-    }
-    lines.push(statusParts.join(" | "));
-    lines.push("");
-    if (fragment.meta.description) {
-      lines.push(fragment.meta.description);
-      lines.push("");
-    }
-    const whenFiltered = filterPlaceholders(fragment.usage.when);
-    const whenNotFiltered = filterPlaceholders(fragment.usage.whenNot);
-    if (include.usage && (whenFiltered.length > 0 || whenNotFiltered.length > 0)) {
-      if (whenFiltered.length > 0) {
-        lines.push("**When to use:**");
-        for (const when of whenFiltered) {
-          lines.push(`- ${when}`);
-        }
-        lines.push("");
-      }
-      if (whenNotFiltered.length > 0) {
-        lines.push("**When NOT to use:**");
-        for (const whenNot of whenNotFiltered) {
-          lines.push(`- ${whenNot}`);
-        }
-        lines.push("");
-      }
-    }
-    if (include.props && Object.keys(fragment.props).length > 0) {
-      lines.push("**Props:**");
-      for (const [name, prop] of Object.entries(fragment.props)) {
-        lines.push(`- \`${name}\`: ${formatPropType(prop)}${prop.required ? " (required)" : ""}`);
-      }
-      lines.push("");
-    }
-    if (include.variants && fragment.variants.length > 0) {
-      const variantNames = fragment.variants.map((v) => v.name).join(", ");
-      lines.push(`**Variants:** ${variantNames}`);
-      lines.push("");
-      if (include.code) {
-        for (const variant of fragment.variants) {
-          if (variant.code) {
-            lines.push(`*${variant.name}:*`);
-            lines.push("```tsx");
-            lines.push(variant.code);
-            lines.push("```");
-            lines.push("");
-          }
-        }
-      }
-    }
-    if (include.relations && fragment.relations && fragment.relations.length > 0) {
-      lines.push("**Related:**");
-      for (const relation of fragment.relations) {
-        lines.push(`- ${relation.component} (${relation.relationship}): ${relation.note}`);
-      }
-      lines.push("");
-    }
-    lines.push("---");
-    lines.push("");
-  }
-  if (blocks && blocks.length > 0) {
-    lines.push("## Blocks");
-    lines.push("");
-    lines.push("Composition patterns showing how components wire together.");
-    lines.push("");
-    for (const block of blocks) {
-      lines.push(`### ${block.name}`);
-      lines.push("");
-      lines.push(block.description);
-      lines.push("");
-      lines.push(`**Category:** ${block.category}`);
-      lines.push(`**Components:** ${block.components.join(", ")}`);
-      if (block.tags && block.tags.length > 0) {
-        lines.push(`**Tags:** ${block.tags.join(", ")}`);
-      }
-      lines.push("");
-      lines.push("```tsx");
-      lines.push(block.code);
-      lines.push("```");
-      lines.push("");
-      lines.push("---");
-      lines.push("");
-    }
-  }
-  const content = lines.join("\n");
-  return { content, tokenEstimate: estimateTokens(content) };
-}
-function generateJsonContext(fragments, include, compact, blocks) {
-  const categories = [...new Set(fragments.map((s) => s.meta.category))].sort();
-  const components = {};
-  for (const fragment of fragments) {
-    const component = {
-      category: fragment.meta.category,
-      description: fragment.meta.description
-    };
-    if (fragment.meta.status) {
-      component.status = fragment.meta.status;
-    }
-    if (!compact) {
-      if (include.usage) {
-        const whenFiltered = filterPlaceholders(fragment.usage.when);
-        const whenNotFiltered = filterPlaceholders(fragment.usage.whenNot);
-        if (whenFiltered.length > 0) component.whenToUse = whenFiltered;
-        if (whenNotFiltered.length > 0) component.whenNotToUse = whenNotFiltered;
-      }
-      if (include.props && Object.keys(fragment.props).length > 0) {
-        component.props = {};
-        for (const [name, prop] of Object.entries(fragment.props)) {
-          component.props[name] = {
-            type: formatPropType(prop),
-            description: prop.description
-          };
-          if (prop.required) component.props[name].required = true;
-          if (prop.default !== void 0) component.props[name].default = prop.default;
-        }
-      }
-      if (include.variants && fragment.variants.length > 0) {
-        component.variants = fragment.variants.map((v) => v.name);
-      }
-      if (include.relations && fragment.relations && fragment.relations.length > 0) {
-        component.relations = fragment.relations.map((r) => ({
-          component: r.component,
-          relationship: r.relationship,
-          note: r.note
-        }));
-      }
-    }
-    components[fragment.meta.name] = component;
-  }
-  const blocksMap = blocks && blocks.length > 0 ? Object.fromEntries(blocks.map((b) => [b.name, {
-    description: b.description,
-    category: b.category,
-    components: b.components,
-    code: b.code,
-    tags: b.tags
-  }])) : void 0;
-  const output = {
-    version: "1.0",
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    summary: {
-      totalComponents: fragments.length,
-      categories,
-      ...blocksMap && { totalBlocks: blocks.length }
-    },
-    components,
-    ...blocksMap && { blocks: blocksMap }
-  };
-  const content = JSON.stringify(output, null, 2);
-  return { content, tokenEstimate: estimateTokens(content) };
-}
-function formatPropType(prop) {
-  if (prop.type === "enum" && prop.values) {
-    return prop.values.map((v) => `"${v}"`).join(" | ");
-  }
-  if (prop.default !== void 0) {
-    return `${prop.type} (default: ${JSON.stringify(prop.default)})`;
-  }
-  return prop.type;
-}
-function truncate(str, maxLength) {
-  if (str.length <= maxLength) return str;
-  return str.slice(0, maxLength - 3) + "...";
-}
-function estimateTokens(text) {
-  return Math.ceil(text.length / 4);
-}
-
-// ../context/dist/chunk-NECSN43I.js
-var MCP_TOOL_DEFINITIONS = [
-  {
-    key: "discover",
-    description: "Discover components in the design system. Use with no params to list all components. Use 'useCase' for AI-powered suggestions. Use 'component' to find alternatives. Use 'compact' for a token-efficient overview.",
-    params: {
-      useCase: {
-        type: "string",
-        description: 'Description of what you want to build \u2014 returns ranked suggestions (e.g., "form for user email input", "button to submit data")'
-      },
-      component: {
-        type: "string",
-        description: 'Component name to find alternatives for (e.g., "Button")'
-      },
-      category: {
-        type: "string",
-        description: 'Filter by category (e.g., "actions", "forms", "layout")'
-      },
-      search: {
-        type: "string",
-        description: "Search term to filter by name, description, or tags"
-      },
-      status: {
-        type: "string",
-        enum: ["stable", "beta", "deprecated", "experimental"],
-        description: "Filter by component status"
-      },
-      format: {
-        type: "string",
-        enum: ["markdown", "json"],
-        description: "Output format for context mode (default: markdown)"
-      },
-      compact: {
-        type: "boolean",
-        description: "If true, returns minimal output (just component names and categories)"
-      },
-      includeCode: {
-        type: "boolean",
-        description: "If true, includes code examples for each variant"
-      },
-      limit: {
-        type: "number",
-        description: "Maximum number of results to return (default: 10 for useCase mode)"
-      },
-      includeRelations: {
-        type: "boolean",
-        description: "If true, includes component relationships"
-      },
-      verbosity: {
-        type: "string",
-        enum: ["compact", "standard", "full"],
-        description: 'Response detail level: "compact" (names only), "standard" (default), "full" (everything including code)'
-      }
-    }
-  },
-  {
-    key: "inspect",
-    description: "Get detailed information about a specific component: props, usage guidelines, code examples, accessibility \u2014 all in one call. Use 'fields' to request only specific data for token efficiency.",
-    params: {
-      component: {
-        type: "string",
-        description: 'Component name (e.g., "Button", "Input")'
-      },
-      fields: {
-        type: "array",
-        items: { type: "string" },
-        description: 'Specific fields to return (e.g., ["meta", "guidelines.when", "contract.propsSummary", "props", "examples"]). If omitted, returns everything. Supports dot notation. Aliases: "usage" \u2192 "guidelines".'
-      },
-      variant: {
-        type: "string",
-        description: 'Filter examples to a specific variant name (e.g., "Default", "Primary")'
-      },
-      maxExamples: {
-        type: "number",
-        description: "Maximum number of code examples to return (default: all)"
-      },
-      maxLines: {
-        type: "number",
-        description: "Maximum lines per code example (truncates longer examples)"
-      },
-      verbosity: {
-        type: "string",
-        enum: ["compact", "standard", "full"],
-        description: 'Response detail level: "compact" (meta + prop names), "standard" (default), "full" (everything)'
-      }
-    },
-    required: ["component"]
-  },
-  {
-    key: "blocks",
-    description: 'Search and retrieve composition blocks \u2014 named patterns showing how design system components wire together for common use cases (e.g., "Login Form", "Settings Page"). Returns the block with its code pattern.',
-    params: {
-      name: {
-        type: "string",
-        description: 'Exact block name to retrieve (e.g., "Login Form")'
-      },
-      search: {
-        type: "string",
-        description: "Free-text search across block names, descriptions, tags, and components"
-      },
-      component: {
-        type: "string",
-        description: 'Filter blocks that use a specific component (e.g., "Button")'
-      },
-      category: {
-        type: "string",
-        description: 'Filter by category (e.g., "authentication", "marketing", "dashboard", "settings", "ecommerce", "ai")'
-      },
-      limit: {
-        type: "number",
-        description: "Maximum number of blocks to return (default: all matching)"
-      },
-      verbosity: {
-        type: "string",
-        enum: ["compact", "standard", "full"],
-        description: 'Response detail level: "compact" (no code), "standard" (default, code preview for long blocks), "full" (full code)'
-      }
-    }
-  },
-  {
-    key: "tokens",
-    description: "List available CSS design tokens (custom properties) by category. Use this when you need to style custom elements or override defaults \u2014 no more guessing variable names. Filter by category or search by keyword.",
-    params: {
-      category: {
-        type: "string",
-        description: 'Filter by category (e.g., "colors", "spacing", "typography", "surfaces", "shadows", "radius", "borders", "text", "focus", "layout", "code", "component-sizing")'
-      },
-      search: {
-        type: "string",
-        description: 'Search token names (e.g., "accent", "hover", "padding")'
-      },
-      limit: {
-        type: "number",
-        description: "Maximum number of tokens to return per category (default: 25 for search, unlimited for category browsing)"
-      }
-    }
-  },
-  {
-    key: "implement",
-    description: "One-shot implementation helper. Describe what you want to build and get everything needed in a single call: best-matching component(s) with full props and code examples, relevant composition blocks, and applicable CSS tokens. Saves multiple round-trips.",
-    params: {
-      useCase: {
-        type: "string",
-        description: 'What you want to implement (e.g., "login form", "data table with sorting", "streaming chat messages")'
-      },
-      limit: {
-        type: "number",
-        description: "Maximum number of components to return (default: 5)"
-      },
-      verbosity: {
-        type: "string",
-        enum: ["compact", "standard", "full"],
-        description: 'Response detail level: "compact" (names only), "standard" (default), "full" (all props + examples + full block code)'
-      }
-    },
-    required: ["useCase"]
-  },
-  {
-    key: "render",
-    description: "Render a component and return a screenshot. Optionally compare against a Figma design ('figmaUrl'). Requires a running Fragments dev server (viewer URL). Use this to verify your implementation looks correct.",
-    params: {
-      component: {
-        type: "string",
-        description: 'Component name (e.g., "Button", "Card", "Input")'
-      },
-      props: {
-        type: "object",
-        description: 'Props to pass to the component (e.g., { "variant": "primary", "children": "Click me" })'
-      },
-      viewport: {
-        type: "object",
-        properties: {
-          width: {
-            type: "number",
-            description: "Viewport width (default: 800)"
-          },
-          height: {
-            type: "number",
-            description: "Viewport height (default: 600)"
-          }
-        },
-        description: "Optional viewport size for the render"
-      },
-      figmaUrl: {
-        type: "string",
-        description: "Figma frame URL \u2014 if provided, compares the render against the Figma design"
-      },
-      variant: {
-        type: "string",
-        description: "Variant name to render (uses the variant's render function from the fragment definition). Works in both render and compare modes."
-      },
-      threshold: {
-        type: "number",
-        description: "Diff threshold percentage (default: 1 for Figma)"
-      }
-    },
-    required: ["component"]
-  },
-  {
-    key: "fix",
-    description: "Generate patches to fix token compliance issues in a component. Returns unified diff patches that replace hardcoded CSS values with design token references. Requires a running Fragments dev server.",
-    params: {
-      component: {
-        type: "string",
-        description: 'Component name to generate fixes for (e.g., "Button", "Card")'
-      },
-      variant: {
-        type: "string",
-        description: "Specific variant to fix (optional, fixes all variants if omitted)"
-      },
-      fixType: {
-        type: "string",
-        enum: ["token", "all"],
-        description: 'Type of fixes to generate: "token" for hardcoded\u2192token replacements, "all" for all available fixes (default: "all")'
-      }
-    },
-    required: ["component"]
-  },
-  {
-    key: "graph",
-    description: 'Query the component relationship graph. Understand dependencies, impact analysis, composition trees, alternatives, and design system health. Use "health" for an overview, "dependencies"/"dependents" for composition and declared relationships (not code-level imports), "impact" for change analysis, "composition" for compound component trees.',
-    params: {
-      mode: {
-        type: "string",
-        enum: ["dependencies", "dependents", "impact", "path", "composition", "alternatives", "islands", "health"],
-        description: "Query mode"
-      },
-      component: {
-        type: "string",
-        description: "Component name (required for most modes)"
-      },
-      target: {
-        type: "string",
-        description: 'Target component for "path" mode'
-      },
-      edgeTypes: {
-        type: "array",
-        items: { type: "string" },
-        description: "Filter by edge types (imports, hook-depends, renders, composes, parent-of, alternative-to, sibling-of)"
-      },
-      maxDepth: {
-        type: "number",
-        description: "Max traversal depth for impact mode (default: 3)"
-      }
-    },
-    required: ["mode"]
-  },
-  {
-    key: "a11y",
-    description: "Run an accessibility audit on a component. Returns axe-core violations, a WCAG compliance score, and optional fix suggestions. Requires a running Fragments dev server.",
-    params: {
-      component: {
-        type: "string",
-        description: 'Component name to audit (e.g., "Button", "Card")'
-      },
-      variant: {
-        type: "string",
-        description: "Specific variant to audit (optional, audits all variants if omitted)"
-      },
-      standard: {
-        type: "string",
-        enum: ["AA", "AAA"],
-        description: "WCAG compliance level to check against (default: AA)"
-      },
-      includeFixPatches: {
-        type: "boolean",
-        description: "If true, includes auto-fix suggestions for each violation"
-      }
-    },
-    required: ["component"]
-  }
-];
-function buildToolNames(prefix) {
-  const map = {};
-  for (const def of MCP_TOOL_DEFINITIONS) {
-    map[def.key] = `${prefix}_${def.key}`;
-  }
-  return map;
-}
-function buildMcpTools(prefix, extensions) {
-  const extMap = /* @__PURE__ */ new Map();
-  if (extensions) {
-    for (const ext of extensions) {
-      extMap.set(ext.key, ext);
-    }
-  }
-  return MCP_TOOL_DEFINITIONS.map((def) => {
-    const ext = extMap.get(def.key);
-    const mergedParams = ext ? { ...def.params, ...ext.params } : def.params;
-    const properties = {};
-    for (const [name, param] of Object.entries(mergedParams)) {
-      const prop = {
-        type: param.type,
-        description: param.description
-      };
-      if (param.enum) prop.enum = param.enum;
-      if (param.items) prop.items = param.items;
-      if (param.properties) {
-        const nested = {};
-        for (const [k, v] of Object.entries(param.properties)) {
-          nested[k] = { type: v.type, description: v.description };
-        }
-        prop.properties = nested;
-      }
-      properties[name] = prop;
-    }
-    return {
-      name: `${prefix}_${def.key}`,
-      description: ext?.description ?? def.description,
-      inputSchema: {
-        type: "object",
-        properties,
-        ...def.required && { required: def.required }
-      }
-    };
-  });
-}
+// src/server.ts
+import { generateContext, filterPlaceholders } from "@fragments-sdk/context/generate";
+import { buildMcpTools, buildToolNames } from "@fragments-sdk/context/mcp-tools";
 
 // src/discovery.ts
 import { existsSync, readFileSync, readdirSync } from "fs";
@@ -1137,7 +595,7 @@ async function hybridSearch(query, data, limit = 10, kind, apiKey) {
   const graphBoostResults = [];
   if (data.graph) {
     try {
-      const { ComponentGraphEngine: ComponentGraphEngine2, deserializeGraph: deserializeGraph2 } = await import("./graph-UWOAWP4T.js");
+      const { ComponentGraphEngine: ComponentGraphEngine2, deserializeGraph: deserializeGraph2 } = await import("@fragments-sdk/context/graph");
       const graph = deserializeGraph2(data.graph);
       const engine = new ComponentGraphEngine2(graph);
       const topComponents = [...keywordResults, ...vectorResults].filter((r) => r.kind === "component").slice(0, 5);
@@ -1378,6 +836,10 @@ function projectFields(obj, fields) {
 }
 
 // src/graph-handler.ts
+import {
+  ComponentGraphEngine,
+  deserializeGraph
+} from "@fragments-sdk/context/graph";
 function handleGraphTool(args, serializedGraph, blocks, componentNames) {
   if (!serializedGraph) {
     return {
@@ -1556,6 +1018,78 @@ function handleGraphTool(args, serializedGraph, blocks, componentNames) {
   }
 }
 
+// src/server-helpers.ts
+function normalizeFilter(value) {
+  const normalized = value?.trim().toLowerCase();
+  return normalized && normalized.length > 0 ? normalized : void 0;
+}
+function categoryMatches(category, categoryFilter) {
+  if (!categoryFilter) return true;
+  return normalizeFilter(category) === categoryFilter;
+}
+function buildLocalSearchData(data, indexes) {
+  const allFragments = Object.values(data.fragments);
+  const allBlocks = Object.values(data.blocks ?? data.recipes ?? {});
+  const localData = {
+    fragments: allFragments,
+    blocks: allBlocks,
+    tokenData: data.tokens,
+    graph: data.graph,
+    componentIndex: indexes.componentIndex ?? void 0,
+    blockIndex: indexes.blockIndex ?? void 0,
+    tokenIndex: indexes.tokenIndex ?? void 0
+  };
+  return { allFragments, allBlocks, localData };
+}
+async function buildImportStatements(components, resolvePackageName) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const component of components) {
+    if (!component) continue;
+    const packageName = await resolvePackageName(component);
+    const existing = grouped.get(packageName);
+    if (!existing) {
+      grouped.set(packageName, [component]);
+      continue;
+    }
+    if (!existing.includes(component)) {
+      existing.push(component);
+    }
+  }
+  return Array.from(grouped.entries()).map(
+    ([packageName, componentNames]) => `import { ${componentNames.join(", ")} } from '${packageName}';`
+  );
+}
+function limitTokensPerCategory(categories, limit) {
+  if (limit === void 0) {
+    return {
+      categories,
+      total: Object.values(categories).reduce((sum, tokens) => sum + tokens.length, 0)
+    };
+  }
+  const limited = {};
+  let total = 0;
+  for (const [category, tokens] of Object.entries(categories)) {
+    const sliced = tokens.slice(0, limit);
+    if (sliced.length === 0) continue;
+    limited[category] = sliced;
+    total += sliced.length;
+  }
+  return { categories: limited, total };
+}
+
+// src/version.ts
+import { readFileSync as readFileSync2 } from "fs";
+function readPackageVersion() {
+  try {
+    const raw = readFileSync2(new URL("../package.json", import.meta.url), "utf-8");
+    const pkg = JSON.parse(raw);
+    return pkg.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+var MCP_SERVER_VERSION = readPackageVersion();
+
 // src/server.ts
 var TOOL_NAMES = buildToolNames(BRAND.nameLower);
 var NO_VIEWER_MSG = "This tool requires a running dev server. Add --viewer-url http://localhost:PORT to this server's config args. Start the viewer with 'fragments dev' in your component library directory.";
@@ -1564,7 +1098,7 @@ function createMcpServer(config) {
   const server = new Server(
     {
       name: `${BRAND.nameLower}-mcp`,
-      version: "0.3.0"
+      version: MCP_SERVER_VERSION
     },
     {
       capabilities: {
@@ -1662,7 +1196,7 @@ If you're a library author, run \`${BRAND.cliCommand} build\` first.`
     const packageJsonPath = join2(root, "package.json");
     if (existsSync2(packageJsonPath)) {
       try {
-        const content = readFileSync2(packageJsonPath, "utf-8");
+        const content = readFileSync3(packageJsonPath, "utf-8");
         const pkg = JSON.parse(content);
         if (pkg.name) {
           defaultPackageName = pkg.name;
@@ -1695,7 +1229,7 @@ If you're a library author, run \`${BRAND.cliCommand} build\` first.`
           const data = await loadFragments();
           const useCase = args?.useCase ?? void 0;
           const componentForAlts = args?.component ?? void 0;
-          const category = args?.category ?? void 0;
+          const category = normalizeFilter(args?.category);
           const search2 = args?.search?.toLowerCase() ?? void 0;
           const status = args?.status ?? void 0;
           const format = args?.format ?? "markdown";
@@ -1708,7 +1242,7 @@ If you're a library author, run \`${BRAND.cliCommand} build\` first.`
             let fragments2 = Object.values(data.fragments);
             const allBlocks = Object.values(data.blocks ?? data.recipes ?? {});
             if (category) {
-              fragments2 = fragments2.filter((f) => f.meta.category?.toLowerCase() === category);
+              fragments2 = fragments2.filter((f) => categoryMatches(f.meta.category, category));
             }
             if (search2) {
               fragments2 = fragments2.filter(
@@ -1732,18 +1266,16 @@ If you're a library author, run \`${BRAND.cliCommand} build\` first.`
             };
           }
           if (useCase) {
-            const allFragments = Object.values(data.fragments);
-            const allBlocks = Object.values(data.blocks ?? data.recipes ?? {});
+            const { allFragments, allBlocks, localData } = buildLocalSearchData(
+              data,
+              {
+                componentIndex,
+                blockIndex,
+                tokenIndex
+              }
+            );
             const context = args?.context?.toLowerCase() ?? "";
             const fullQuery = context ? `${useCase} ${context}` : useCase;
-            const localData = {
-              fragments: allFragments,
-              blocks: allBlocks,
-              tokenData: data.tokens,
-              componentIndex: componentIndex ?? void 0,
-              blockIndex: blockIndex ?? void 0,
-              tokenIndex: tokenIndex ?? void 0
-            };
             const searchResults = await hybridSearch(fullQuery, localData, limit, "component", config.apiKey);
             const blockMatches = keywordScoreBlocks(fullQuery, allBlocks, blockIndex ?? void 0).slice(0, 5);
             if (blockMatches.length > 0) {
@@ -1874,7 +1406,7 @@ If you're a library author, run \`${BRAND.cliCommand} build\` first.`
             };
           }
           const fragments = Object.values(data.fragments).filter((s) => {
-            if (category && s.meta.category !== category) return false;
+            if (category && !categoryMatches(s.meta.category, category)) return false;
             if (status && (s.meta.status ?? "stable") !== status) return false;
             if (search2) {
               const nameMatch = s.meta.name.toLowerCase().includes(search2);
@@ -2107,23 +1639,27 @@ If you're a library author, run \`${BRAND.cliCommand} build\` first.`
           if (blocksLimit !== void 0) {
             filtered = filtered.slice(0, blocksLimit);
           }
-          const pkgName = fragmentPackageMap.values().next().value ?? "your-component-library";
           const verbosity = args?.verbosity ?? "standard";
-          const blocksWithImports = filtered.map((b) => {
+          const blocksWithImports = await Promise.all(filtered.map(async (b) => {
+            const imports = await buildImportStatements(
+              b.components,
+              async (componentName) => getPackageName(componentName)
+            );
             const base = {
               name: b.name,
               description: b.description,
               category: b.category,
               components: b.components,
               tags: b.tags,
-              import: `import { ${b.components.join(", ")} } from '${pkgName}';`
+              import: imports.join("\n"),
+              imports
             };
             if (verbosity === "compact") return base;
             if (verbosity === "full") return { ...base, code: b.code };
             const codeLines = b.code.split("\n");
             const code = codeLines.length > 30 ? codeLines.slice(0, 20).join("\n") + "\n// ... truncated (" + codeLines.length + " lines total)" : b.code;
             return { ...base, code };
-          });
+          }));
           return {
             content: [{
               type: "text",
@@ -2180,15 +1716,9 @@ If you're a library author, run \`${BRAND.cliCommand} build\` first.`
             }
           }
           if (tokensLimit !== void 0) {
-            let remaining = tokensLimit;
-            const limited = {};
-            for (const [cat, tokens] of Object.entries(filteredCategories)) {
-              if (remaining <= 0) break;
-              limited[cat] = tokens.slice(0, remaining);
-              remaining -= limited[cat].length;
-            }
-            filteredCategories = limited;
-            filteredTotal = Math.min(filteredTotal, tokensLimit);
+            const limited = limitTokensPerCategory(filteredCategories, tokensLimit);
+            filteredCategories = limited.categories;
+            filteredTotal = limited.total;
           }
           let hint;
           if (filteredTotal === 0) {
@@ -2232,18 +1762,16 @@ If you're a library author, run \`${BRAND.cliCommand} build\` first.`
             throw new Error("useCase is required");
           }
           const verbosity = args?.verbosity ?? "standard";
-          const allFragments = Object.values(data.fragments);
-          const allBlocks = Object.values(data.blocks ?? data.recipes ?? {});
+          const { allFragments, allBlocks, localData } = buildLocalSearchData(
+            data,
+            {
+              componentIndex,
+              blockIndex,
+              tokenIndex
+            }
+          );
           const tokenData = data.tokens;
           const implLimit = typeof args?.limit === "number" ? Math.min(Math.max(args.limit, 1), 15) : 5;
-          const localData = {
-            fragments: allFragments,
-            blocks: allBlocks,
-            tokenData,
-            componentIndex: componentIndex ?? void 0,
-            blockIndex: blockIndex ?? void 0,
-            tokenIndex: tokenIndex ?? void 0
-          };
           const [componentResults, blockResults, tokenResults] = await Promise.all([
             hybridSearch(useCase, localData, implLimit * 3, "component", config.apiKey),
             hybridSearch(useCase, localData, implLimit, "block", config.apiKey),
@@ -2297,12 +1825,15 @@ If you're a library author, run \`${BRAND.cliCommand} build\` first.`
               };
             })
           );
-          const matchingBlocks = filteredBlockResults.slice(0, 5).map((result) => {
+          const matchingBlocks = (await Promise.all(filteredBlockResults.slice(0, 5).map(async (result) => {
             const block = allBlocks.find(
               (b) => b.name.toLowerCase() === result.name.toLowerCase()
             );
             if (!block) return null;
-            const pkgName = fragmentPackageMap.values().next().value ?? "your-component-library";
+            const imports = await buildImportStatements(
+              block.components,
+              async (componentName) => getPackageName(componentName)
+            );
             const codeLines = block.code.split("\n");
             const code = codeLines.length > 30 ? codeLines.slice(0, 20).join("\n") + "\n// ... truncated (" + codeLines.length + " lines total)" : block.code;
             return {
@@ -2310,9 +1841,10 @@ If you're a library author, run \`${BRAND.cliCommand} build\` first.`
               description: block.description,
               components: block.components,
               code,
-              import: `import { ${block.components.join(", ")} } from '${pkgName}';`
+              import: imports.join("\n"),
+              imports
             };
-          }).filter(Boolean);
+          }))).filter(Boolean);
           let relevantTokens;
           if (tokenResults.length > 0 && tokenData) {
             relevantTokens = {};
@@ -2693,4 +2225,4 @@ export {
   startMcpServer,
   createSandboxServer
 };
-//# sourceMappingURL=chunk-SZ63UDGU.js.map
+//# sourceMappingURL=chunk-XMNCAB2A.js.map