pdfx-cli 0.0.1 → 0.4.0

package/dist/mcp/index.js

@@ -0,0 +1,1261 @@
+// src/mcp/index.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { z as z8 } from "zod";
+import { zodToJsonSchema } from "zod-to-json-schema";
+
+// src/mcp/tools/add-command.ts
+import dedent from "dedent";
+import { z as z2 } from "zod";
+
+// ../shared/src/schemas.ts
+import { z } from "zod";
+var colorTokensSchema = z.object({
+  foreground: z.string().min(1),
+  background: z.string().min(1),
+  muted: z.string().min(1),
+  mutedForeground: z.string().min(1),
+  primary: z.string().min(1),
+  primaryForeground: z.string().min(1),
+  border: z.string().min(1),
+  accent: z.string().min(1),
+  destructive: z.string().min(1),
+  success: z.string().min(1),
+  warning: z.string().min(1),
+  info: z.string().min(1)
+});
+var headingFontSizeSchema = z.object({
+  h1: z.number().positive(),
+  h2: z.number().positive(),
+  h3: z.number().positive(),
+  h4: z.number().positive(),
+  h5: z.number().positive(),
+  h6: z.number().positive()
+});
+var typographyTokensSchema = z.object({
+  body: z.object({
+    fontFamily: z.string().min(1),
+    fontSize: z.number().positive(),
+    lineHeight: z.number().positive()
+  }),
+  heading: z.object({
+    fontFamily: z.string().min(1),
+    fontWeight: z.number().int().min(100).max(900),
+    lineHeight: z.number().positive(),
+    fontSize: headingFontSizeSchema
+  })
+});
+var spacingTokensSchema = z.object({
+  page: z.object({
+    marginTop: z.number().min(0),
+    marginRight: z.number().min(0),
+    marginBottom: z.number().min(0),
+    marginLeft: z.number().min(0)
+  }),
+  sectionGap: z.number().min(0),
+  paragraphGap: z.number().min(0),
+  componentGap: z.number().min(0)
+});
+var pageTokensSchema = z.object({
+  size: z.enum(["A4", "LETTER", "LEGAL"]),
+  orientation: z.enum(["portrait", "landscape"])
+});
+var primitiveTokensSchema = z.object({
+  typography: z.record(z.number()),
+  spacing: z.record(z.number()),
+  fontWeights: z.object({
+    regular: z.number(),
+    medium: z.number(),
+    semibold: z.number(),
+    bold: z.number()
+  }),
+  lineHeights: z.object({
+    tight: z.number(),
+    normal: z.number(),
+    relaxed: z.number()
+  }),
+  borderRadius: z.object({
+    none: z.number(),
+    sm: z.number(),
+    md: z.number(),
+    lg: z.number(),
+    full: z.number()
+  }),
+  letterSpacing: z.object({
+    tight: z.number(),
+    normal: z.number(),
+    wide: z.number(),
+    wider: z.number()
+  })
+});
+var themeSchema = z.object({
+  name: z.string().min(1),
+  primitives: primitiveTokensSchema,
+  colors: colorTokensSchema,
+  typography: typographyTokensSchema,
+  spacing: spacingTokensSchema,
+  page: pageTokensSchema
+});
+var configSchema = z.object({
+  $schema: z.string().optional(),
+  componentDir: z.string().min(1, "componentDir must not be empty"),
+  registry: z.string().url("registry must be a valid URL"),
+  theme: z.string().min(1).optional(),
+  blockDir: z.string().min(1).optional()
+});
+var registryFileTypes = [
+  "registry:component",
+  "registry:lib",
+  "registry:style",
+  "registry:template",
+  "registry:block",
+  "registry:file"
+];
+var registryFileSchema = z.object({
+  path: z.string().min(1),
+  content: z.string(),
+  type: z.enum(registryFileTypes)
+});
+var registryItemSchema = z.object({
+  name: z.string().min(1),
+  type: z.string().optional(),
+  title: z.string().optional(),
+  description: z.string().optional(),
+  files: z.array(registryFileSchema).min(1, "Component must have at least one file"),
+  dependencies: z.array(z.string()).optional(),
+  devDependencies: z.array(z.string()).optional(),
+  registryDependencies: z.array(z.string()).optional(),
+  peerComponents: z.array(z.string()).optional()
+});
+var registryIndexItemSchema = z.object({
+  name: z.string().min(1),
+  type: z.string(),
+  title: z.string(),
+  description: z.string(),
+  files: z.array(
+    z.object({
+      path: z.string().min(1),
+      type: z.string()
+    })
+  ),
+  dependencies: z.array(z.string()).optional(),
+  devDependencies: z.array(z.string()).optional(),
+  registryDependencies: z.array(z.string()).optional(),
+  peerComponents: z.array(z.string()).optional()
+});
+var registrySchema = z.object({
+  $schema: z.string(),
+  name: z.string(),
+  homepage: z.string(),
+  items: z.array(registryIndexItemSchema)
+});
+var componentNameSchema = z.string().regex(
+  /^[a-z][a-z0-9-]*$/,
+  "Component name must start with a lowercase letter and contain only lowercase letters, numbers, and hyphens"
+);
+
+// ../shared/src/themes/primitives.ts
+var defaultPrimitives = {
+  typography: {
+    xs: 10,
+    sm: 12,
+    base: 15,
+    lg: 18,
+    xl: 22,
+    "2xl": 28,
+    "3xl": 36
+  },
+  spacing: {
+    0: 0,
+    0.5: 2,
+    1: 4,
+    2: 8,
+    3: 12,
+    4: 16,
+    5: 20,
+    6: 24,
+    8: 32,
+    10: 40,
+    12: 48,
+    16: 64
+  },
+  fontWeights: {
+    regular: 400,
+    medium: 500,
+    semibold: 600,
+    bold: 700
+  },
+  lineHeights: {
+    tight: 1.2,
+    normal: 1.4,
+    relaxed: 1.6
+  },
+  borderRadius: {
+    none: 0,
+    sm: 2,
+    md: 4,
+    lg: 8,
+    full: 9999
+  },
+  letterSpacing: {
+    tight: -0.025,
+    normal: 0,
+    wide: 0.025,
+    wider: 0.05
+  }
+};
+
+// ../shared/src/themes/professional.ts
+var professionalTheme = {
+  name: "professional",
+  primitives: defaultPrimitives,
+  colors: {
+    foreground: "#18181b",
+    background: "#ffffff",
+    muted: "#f4f4f5",
+    mutedForeground: "#71717a",
+    primary: "#18181b",
+    primaryForeground: "#ffffff",
+    border: "#e4e4e7",
+    accent: "#3b82f6",
+    destructive: "#dc2626",
+    success: "#16a34a",
+    warning: "#d97706",
+    info: "#0ea5e9"
+  },
+  typography: {
+    body: {
+      fontFamily: "Helvetica",
+      fontSize: 11,
+      lineHeight: 1.6
+    },
+    heading: {
+      fontFamily: "Times-Roman",
+      fontWeight: 700,
+      lineHeight: 1.25,
+      fontSize: {
+        h1: 32,
+        h2: 24,
+        h3: 20,
+        h4: 16,
+        h5: 14,
+        h6: 12
+      }
+    }
+  },
+  spacing: {
+    page: {
+      marginTop: 56,
+      marginRight: 48,
+      marginBottom: 56,
+      marginLeft: 48
+    },
+    sectionGap: 28,
+    paragraphGap: 10,
+    componentGap: 14
+  },
+  page: {
+    size: "A4",
+    orientation: "portrait"
+  }
+};
+
+// ../shared/src/themes/modern.ts
+var modernTheme = {
+  name: "modern",
+  primitives: defaultPrimitives,
+  colors: {
+    foreground: "#0f172a",
+    background: "#ffffff",
+    muted: "#f1f5f9",
+    mutedForeground: "#64748b",
+    primary: "#334155",
+    primaryForeground: "#ffffff",
+    border: "#e2e8f0",
+    accent: "#6366f1",
+    destructive: "#ef4444",
+    success: "#22c55e",
+    warning: "#f59e0b",
+    info: "#3b82f6"
+  },
+  typography: {
+    body: {
+      fontFamily: "Helvetica",
+      fontSize: 11,
+      lineHeight: 1.6
+    },
+    heading: {
+      fontFamily: "Helvetica",
+      fontWeight: 600,
+      lineHeight: 1.25,
+      fontSize: {
+        h1: 28,
+        h2: 22,
+        h3: 18,
+        h4: 16,
+        h5: 14,
+        h6: 12
+      }
+    }
+  },
+  spacing: {
+    page: {
+      marginTop: 40,
+      marginRight: 40,
+      marginBottom: 40,
+      marginLeft: 40
+    },
+    sectionGap: 24,
+    paragraphGap: 10,
+    componentGap: 12
+  },
+  page: {
+    size: "A4",
+    orientation: "portrait"
+  }
+};
+
+// ../shared/src/themes/minimal.ts
+var minimalTheme = {
+  name: "minimal",
+  primitives: defaultPrimitives,
+  colors: {
+    foreground: "#18181b",
+    background: "#ffffff",
+    muted: "#fafafa",
+    mutedForeground: "#a1a1aa",
+    primary: "#18181b",
+    primaryForeground: "#ffffff",
+    border: "#e4e4e7",
+    accent: "#71717a",
+    destructive: "#b91c1c",
+    success: "#15803d",
+    warning: "#a16207",
+    info: "#0369a1"
+  },
+  typography: {
+    body: {
+      fontFamily: "Helvetica",
+      fontSize: 11,
+      lineHeight: 1.65
+    },
+    heading: {
+      fontFamily: "Courier",
+      fontWeight: 600,
+      lineHeight: 1.25,
+      fontSize: {
+        h1: 24,
+        h2: 20,
+        h3: 16,
+        h4: 14,
+        h5: 12,
+        h6: 10
+      }
+    }
+  },
+  spacing: {
+    page: {
+      marginTop: 72,
+      marginRight: 56,
+      marginBottom: 72,
+      marginLeft: 56
+    },
+    sectionGap: 36,
+    paragraphGap: 14,
+    componentGap: 18
+  },
+  page: {
+    size: "A4",
+    orientation: "portrait"
+  }
+};
+
+// ../shared/src/themes/index.ts
+var themePresets = {
+  professional: professionalTheme,
+  modern: modernTheme,
+  minimal: minimalTheme
+};
+
+// ../shared/src/errors.ts
+var PdfxError = class extends Error {
+  constructor(message, code, suggestion) {
+    super(message);
+    this.code = code;
+    this.suggestion = suggestion;
+    this.name = "PdfxError";
+  }
+};
+var RegistryError = class extends PdfxError {
+  constructor(message, suggestion) {
+    super(message, "REGISTRY_ERROR", suggestion);
+    this.name = "RegistryError";
+  }
+};
+var NetworkError = class extends PdfxError {
+  constructor(message, suggestion) {
+    super(
+      message,
+      "NETWORK_ERROR",
+      suggestion ?? "Check your internet connection and registry URL"
+    );
+    this.name = "NetworkError";
+  }
+};
+
+// src/constants.ts
+var DEFAULTS = {
+  REGISTRY_URL: "https://pdfx.akashpise.dev/r",
+  SCHEMA_URL: "https://pdfx.akashpise.dev/schema.json",
+  COMPONENT_DIR: "./src/components/pdfx",
+  THEME_FILE: "./src/lib/pdfx-theme.ts",
+  BLOCK_DIR: "./src/blocks/pdfx"
+};
+var REGISTRY_SUBPATHS = {
+  BLOCKS: "blocks"
+};
+var FETCH_TIMEOUT_MS = 1e4;
+
+// src/mcp/utils.ts
+var REGISTRY_BASE = DEFAULTS.REGISTRY_URL;
+var BLOCKS_BASE = `${DEFAULTS.REGISTRY_URL}/${REGISTRY_SUBPATHS.BLOCKS}`;
+async function fetchRegistryIndex() {
+  let response;
+  try {
+    response = await fetch(`${REGISTRY_BASE}/index.json`, {
+      signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
+    });
+  } catch (err) {
+    const isTimeout = err instanceof Error && err.name === "TimeoutError";
+    throw new NetworkError(
+      isTimeout ? "Registry request timed out. Check your internet connection." : "Could not reach the PDFx registry. Check your internet connection."
+    );
+  }
+  if (!response.ok) {
+    throw new RegistryError(`Registry returned HTTP ${response.status}`);
+  }
+  let data;
+  try {
+    data = await response.json();
+  } catch {
+    throw new RegistryError("Registry returned invalid JSON");
+  }
+  const result = registrySchema.safeParse(data);
+  if (!result.success) {
+    throw new RegistryError("Registry index has an unexpected format");
+  }
+  return result.data.items;
+}
+async function fetchRegistryItem(name, base = REGISTRY_BASE) {
+  const url = `${base}/${name}.json`;
+  let response;
+  try {
+    response = await fetch(url, {
+      signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
+    });
+  } catch (err) {
+    const isTimeout = err instanceof Error && err.name === "TimeoutError";
+    throw new NetworkError(
+      isTimeout ? `Registry request timed out for "${name}".` : "Could not reach the PDFx registry. Check your internet connection."
+    );
+  }
+  if (!response.ok) {
+    if (response.status === 404) {
+      throw new RegistryError(
+        `"${name}" not found in the registry. Use list_components or list_blocks to see available items.`
+      );
+    }
+    throw new RegistryError(`Registry returned HTTP ${response.status} for "${name}"`);
+  }
+  let data;
+  try {
+    data = await response.json();
+  } catch {
+    throw new RegistryError(`Registry returned invalid JSON for "${name}"`);
+  }
+  const result = registryItemSchema.safeParse(data);
+  if (!result.success) {
+    throw new RegistryError(`Unexpected registry format for "${name}"`);
+  }
+  return result.data;
+}
+function textResponse(text) {
+  return { content: [{ type: "text", text }] };
+}
+function errorResponse(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return {
+    content: [{ type: "text", text: `Error: ${message}` }],
+    isError: true
+  };
+}
+
+// src/mcp/tools/add-command.ts
+var getAddCommandSchema = z2.object({
+  items: z2.array(z2.string().min(1)).min(1).describe(
+    "Item names to add, e.g. ['table', 'heading'] for components or ['invoice-modern'] for blocks"
+  ),
+  type: z2.enum(["component", "block"]).describe("Whether the items are components or blocks")
+});
+async function getAddCommand(args) {
+  const isBlock = args.type === "block";
+  const cmd = isBlock ? `npx pdfx-cli block add ${args.items.join(" ")}` : `npx pdfx-cli add ${args.items.join(" ")}`;
+  const installDir = isBlock ? "src/blocks/pdfx/" : "src/components/pdfx/";
+  const inspectTool = isBlock ? "get_block" : "get_component";
+  const itemList = args.items.map((i) => `- \`${i}\``).join("\n");
+  return textResponse(dedent`
+    # Add Command
+
+    \`\`\`bash
+    ${cmd}
+    \`\`\`
+
+    **Items:**
+    ${itemList}
+
+    **What this does:**
+    - Copies source files into \`${installDir}\`
+    - You own the code — no runtime package is added
+    ${isBlock ? "- The block includes a complete document layout ready to customize" : "- Each component gets its own subdirectory inside componentDir"}
+
+    **Before running:** make sure \`pdfx.json\` exists. Run \`npx pdfx-cli init\` if not.
+
+    **See source first:** call \`${inspectTool}\` with the item name to review the code before adding.
+
+    **After adding:** call \`get_audit_checklist\` to verify your setup is correct.
+  `);
+}
+
+// src/mcp/tools/audit.ts
+import dedent2 from "dedent";
+async function getAuditChecklist() {
+  return textResponse(dedent2`
+    # PDFx Setup Audit Checklist
+
+    Work through this after adding components or generating PDF document code.
+
+    ## Configuration
+    - [ ] \`pdfx.json\` exists in the project root
+    - [ ] \`componentDir\` path in \`pdfx.json\` is correct (default: \`./src/components/pdfx\`)
+    - [ ] Theme file exists at the path set in \`pdfx.json\` (default: \`./src/lib/pdfx-theme.ts\`)
+
+    ## Dependencies
+    - [ ] \`@react-pdf/renderer\` is installed — run \`npm ls @react-pdf/renderer\` to confirm
+    - [ ] Version is ≥ 3.0.0 (PDFx requires react-pdf v3+)
+
+    ## Imports
+    - [ ] PDFx components use **named exports**: \`import { Table, Heading } from '@/components/pdfx/...'\`
+    - [ ] \`Document\` and \`Page\` are imported from \`@react-pdf/renderer\`, not from PDFx
+    - [ ] No Tailwind classes, CSS variables, or DOM APIs are used inside PDF components
+    - [ ] All styles use \`StyleSheet.create({})\` from \`@react-pdf/renderer\`
+
+    ## Rendering
+    - [ ] The root PDF component is **not** inside a React Server Component
+    - [ ] Using \`renderToBuffer\`, \`PDFViewer\`, or \`PDFDownloadLink\` to render the document
+    - [ ] Root component returns \`<Document><Page>...</Page></Document>\`
+    - [ ] No console errors about missing fonts
+
+    ## TypeScript
+    - [ ] No TypeScript errors in component files
+    - [ ] Theme is typed as \`PdfxTheme\` (imported as a type from \`@pdfx/shared\`)
+
+    ---
+
+    ## Common Issues & Fixes
+
+    ### "Cannot find module @/components/pdfx/..."
+    The component hasn't been added yet. Run:
+    \`\`\`bash
+    npx pdfx-cli add <component-name>
+    \`\`\`
+
+    ### "Invalid hook call"
+    PDFx components render to PDF, not to the DOM — React hooks are not supported inside them.
+    Move hook calls to the parent component and pass data down as props.
+
+    ### "Text strings must be rendered inside \`<Text>\` component"
+    Wrap all string literals in \`<Text>\` from \`@react-pdf/renderer\`:
+    \`\`\`tsx
+    import { Text } from '@react-pdf/renderer';
+    // ✗ Wrong: <View>Hello</View>
+    // ✓ Correct: <View><Text>Hello</Text></View>
+    \`\`\`
+
+    ### Fonts not loading / rendering as a fallback
+    Register custom fonts in your theme file:
+    \`\`\`tsx
+    import { Font } from '@react-pdf/renderer';
+
+    Font.register({
+      family: 'Inter',
+      src: 'https://fonts.gstatic.com/s/inter/v13/UcCO3FwrK3iLTeHuS_fvQtMwCp50KnMw2boKoduKmMEVuLyfAZ9hiA.woff2',
+    });
+    \`\`\`
+
+    ### PDF renders blank or empty
+    Ensure your root component returns a \`<Document>\` with at least one \`<Page>\` inside:
+    \`\`\`tsx
+    import { Document, Page } from '@react-pdf/renderer';
+
+    export function MyDocument() {
+      return (
+        <Document>
+          <Page size="A4">
+            {/* content here */}
+          </Page>
+        </Document>
+      );
+    }
+    \`\`\`
+
+    ### @react-pdf/renderer TypeScript errors
+    Install the types package:
+    \`\`\`bash
+    npm install --save-dev @react-pdf/types
+    \`\`\`
+
+    ---
+
+    ## @react-pdf/renderer Layout Constraints
+
+    These are **fundamental PDF rendering limitations** — they cannot be fixed with CSS-like
+    style tweaks. Understanding them will save hours of debugging.
+
+    ### ⚠️ CRITICAL: Do NOT mix \`<View>\` and \`<Text>\` in the same flex row
+
+    In HTML, inline elements (spans, badges) can sit next to block text freely.
+    In \`@react-pdf/renderer\`, \`View\` and \`Text\` are fundamentally different node types.
+    Placing a \`View\`-based component (e.g. \`<Badge>\`, \`<PdfAlert>\`) **inline** alongside
+    a \`<Text>\` node in the same flex row causes irrecoverable misalignment, overlap, and
+    overflow that no amount of padding, margin, or \`alignItems\` can fix.
+
+    **Wrong — will cause layout corruption:**
+    \`\`\`tsx
+    {/* Badge is a View; Text is a Text node — they CANNOT share a flex row */}
+    <View style={{ flexDirection: 'row', alignItems: 'center', gap: 6 }}>
+      <Text>INV-2026-001</Text>
+      <Badge label="PAID" variant="success" />
+    </View>
+    \`\`\`
+
+    **Correct — place View-based components on their own line:**
+    \`\`\`tsx
+    <View style={{ flexDirection: 'column', gap: 2 }}>
+      <Text>INV-2026-001</Text>
+      <Badge label="PAID" variant="success" />
+    </View>
+    \`\`\`
+
+    PDFx components that are \`View\`-based (cannot be mixed inline with \`<Text>\`):
+    \`Badge\`, \`PdfAlert\`, \`Card\`, \`Divider\`, \`KeyValue\`, \`Section\`, \`Table\`, \`DataTable\`,
+    \`PdfGraph\`, \`PdfImage\`, \`PdfSignatureBlock\`, \`PdfList\`
+
+    ### No \`position: absolute\` stacking inside \`<Text>\` nodes
+    Absolute positioning works on \`View\` elements but not inside \`Text\` runs.
+
+    ### \`gap\` only works between \`View\` siblings
+    Use \`gap\` on a \`View\` container whose children are all \`View\` elements.
+    If any child is a raw \`Text\` node, use \`marginBottom\` on siblings instead.
+
+    ### No percentage-based font sizes
+    \`@react-pdf/renderer\` requires numeric pt/px values for \`fontSize\`. Do not use strings like \`"1rem"\` or \`"120%"\`.
+  `);
+}
+
+// src/mcp/tools/blocks.ts
+import dedent3 from "dedent";
+import { z as z3 } from "zod";
+var listBlocksSchema = z3.object({});
+async function listBlocks() {
+  const items = await fetchRegistryIndex();
+  const blocks = items.filter((i) => i.type === "registry:block");
+  const invoices = blocks.filter((b) => b.name.startsWith("invoice-"));
+  const reports = blocks.filter((b) => b.name.startsWith("report-"));
+  const others = blocks.filter(
+    (b) => !b.name.startsWith("invoice-") && !b.name.startsWith("report-")
+  );
+  const formatBlock = (b) => {
+    const peers = b.peerComponents?.length ? ` _(requires: ${b.peerComponents.join(", ")})_` : "";
+    return `- **${b.name}** \u2014 ${b.description ?? "No description"}${peers}`;
+  };
+  const sections = [];
+  if (invoices.length > 0) {
+    sections.push(
+      `### Invoice Blocks (${invoices.length})
+${invoices.map(formatBlock).join("\n")}`
+    );
+  }
+  if (reports.length > 0) {
+    sections.push(`### Report Blocks (${reports.length})
+${reports.map(formatBlock).join("\n")}`);
+  }
+  if (others.length > 0) {
+    sections.push(`### Other Blocks (${others.length})
+${others.map(formatBlock).join("\n")}`);
+  }
+  return textResponse(dedent3`
+    # PDFx Blocks (${blocks.length})
+
+    Blocks are complete, copy-paste ready document layouts. Unlike components, they are full documents ready to customize.
+
+    ${sections.join("\n\n")}
+
+    ---
+    Add a block: \`npx pdfx-cli block add <name>\`
+    See full source: call \`get_block\` with the block name
+  `);
+}
+var getBlockSchema = z3.object({
+  block: z3.string().min(1).describe("Block name, e.g. 'invoice-modern', 'report-financial'")
+});
+async function getBlock(args) {
+  const item = await fetchRegistryItem(args.block, BLOCKS_BASE);
+  const fileList = item.files.map((f) => `- \`${f.path}\``).join("\n");
+  const peers = item.peerComponents?.length ? item.peerComponents.join(", ") : "none";
+  const fileSources = item.files.map(
+    (f) => dedent3`
+        ### \`${f.path}\`
+        \`\`\`tsx
+        ${f.content}
+        \`\`\`
+      `
+  ).join("\n\n");
+  return textResponse(dedent3`
+    # ${item.title ?? item.name}
+
+    ${item.description ?? ""}
+
+    ## Files
+    ${fileList}
+
+    ## Required PDFx Components
+    ${peers}
+
+    ## Add Command
+    \`\`\`bash
+    npx pdfx-cli block add ${args.block}
+    \`\`\`
+
+    ## Source Code
+    ${fileSources}
+  `);
+}
+
+// src/mcp/tools/components.ts
+import dedent4 from "dedent";
+import { z as z4 } from "zod";
+var listComponentsSchema = z4.object({});
+async function listComponents() {
+  const items = await fetchRegistryIndex();
+  const components = items.filter((i) => i.type === "registry:ui");
+  const rows = components.map((c) => `- **${c.name}** \u2014 ${c.description ?? "No description"}`).join("\n");
+  return textResponse(dedent4`
+    # PDFx Components (${components.length})
+
+    ${rows}
+
+    ---
+    Add a component: \`npx pdfx-cli add <name>\`
+    See full source, props, and exact export name: call \`get_component\` with the component name
+  `);
+}
+var getComponentSchema = z4.object({
+  component: z4.string().min(1).describe("Component name, e.g. 'table', 'heading', 'data-table'")
+});
+async function getComponent(args) {
+  const item = await fetchRegistryItem(args.component);
+  const fileList = item.files.map((f) => `- \`${f.path}\``).join("\n");
+  const deps = item.dependencies?.length ? item.dependencies.join(", ") : "none";
+  const devDeps = item.devDependencies?.length ? item.devDependencies.join(", ") : "none";
+  const registryDeps = item.registryDependencies?.length ? item.registryDependencies.join(", ") : "none";
+  const primaryContent = item.files[0]?.content ?? "";
+  const primaryPath = item.files[0]?.path ?? "";
+  const exportNames = extractAllExportNames(primaryContent);
+  const mainExport = extractExportName(primaryContent);
+  const exportSection = exportNames.length > 0 ? dedent4`
+          ## Exports
+          **Main component export:** \`${mainExport ?? exportNames[0]}\`
+
+          All named exports from \`${primaryPath}\`:
+          ${exportNames.map((n) => `- \`${n}\``).join("\n")}
+
+          **Import after \`npx pdfx-cli@latest add ${args.component}\`:**
+          \`\`\`tsx
+          import { ${mainExport ?? exportNames[0]} } from './components/pdfx/${args.component}/pdfx-${args.component}';
+          \`\`\`
+        ` : "";
+  const fileSources = item.files.map(
+    (f) => dedent4`
+        ### \`${f.path}\`
+        \`\`\`tsx
+        ${f.content}
+        \`\`\`
+      `
+  ).join("\n\n");
+  return textResponse(dedent4`
+    # ${item.title ?? item.name}
+
+    ${item.description ?? ""}
+
+    ## Files
+    ${fileList}
+
+    ## Dependencies
+    - Runtime: ${deps}
+    - Dev: ${devDeps}
+    - Other PDFx components required: ${registryDeps}
+
+    ${exportSection}
+
+    ## Add Command
+    \`\`\`bash
+    npx pdfx-cli add ${args.component}
+    \`\`\`
+
+    ## Source Code
+    ${fileSources}
+  `);
+}
+function extractExportName(source) {
+  if (!source) return null;
+  const matches = [...source.matchAll(/export\s+(?:function|const)\s+([A-Z][A-Za-z0-9]*)/g)];
+  if (matches.length === 0) return null;
+  return matches[0][1] ?? null;
+}
+function extractAllExportNames(source) {
+  const seen = /* @__PURE__ */ new Set();
+  const results = [];
+  for (const m of source.matchAll(/export\s+(?:function|const|class)\s+([A-Za-z][A-Za-z0-9]*)/g)) {
+    const name = m[1];
+    if (name && !seen.has(name)) {
+      seen.add(name);
+      results.push(name);
+    }
+  }
+  for (const m of source.matchAll(/export\s+\{([^}]+)\}/g)) {
+    for (const part of m[1].split(",")) {
+      const name = part.trim().split(/\s+as\s+/).pop()?.trim();
+      if (name && /^[A-Za-z]/.test(name) && !seen.has(name)) {
+        seen.add(name);
+        results.push(name);
+      }
+    }
+  }
+  return results;
+}
+
+// src/mcp/tools/installation.ts
+import dedent5 from "dedent";
+import { z as z5 } from "zod";
+var getInstallationSchema = z5.object({
+  framework: z5.enum(["nextjs", "react", "vite", "remix", "other"]).describe("Target framework"),
+  package_manager: z5.enum(["npm", "pnpm", "yarn", "bun"]).describe("Package manager to use")
+});
+function installCmd(pm, pkg, dev = false) {
+  const base = { npm: "npm install", pnpm: "pnpm add", yarn: "yarn add", bun: "bun add" }[pm];
+  const devFlag = { npm: "--save-dev", pnpm: "-D", yarn: "--dev", bun: "-d" }[pm];
+  return dev ? `${base} ${devFlag} ${pkg}` : `${base} ${pkg}`;
+}
+var FRAMEWORK_NOTES = {
+  nextjs: dedent5`
+    ## Next.js Notes
+
+    **App Router** — Use a Route Handler to serve PDFs:
+    \`\`\`tsx
+    // app/api/pdf/route.ts
+    import { renderToBuffer } from '@react-pdf/renderer';
+    import { MyDocument } from '@/components/pdfx/my-document';
+
+    export async function GET() {
+      const buffer = await renderToBuffer(<MyDocument />);
+      return new Response(buffer, {
+        headers: { 'Content-Type': 'application/pdf' },
+      });
+    }
+    \`\`\`
+
+    **Important:** Do NOT render PDFx components inside React Server Components.
+    Always use a \`'use client'\` boundary or a Route Handler.
+
+    **Pages Router** — Use an API route:
+    \`\`\`tsx
+    // pages/api/pdf.ts
+    import type { NextApiRequest, NextApiResponse } from 'next';
+    import { renderToBuffer } from '@react-pdf/renderer';
+    import { MyDocument } from '@/components/pdfx/my-document';
+
+    export default async function handler(req: NextApiRequest, res: NextApiResponse) {
+      const buffer = await renderToBuffer(<MyDocument />);
+      res.setHeader('Content-Type', 'application/pdf');
+      res.send(buffer);
+    }
+    \`\`\`
+  `,
+  react: dedent5`
+    ## React Notes
+
+    Display a PDF inline with \`PDFViewer\`:
+    \`\`\`tsx
+    import { PDFViewer } from '@react-pdf/renderer';
+    import { MyDocument } from './components/pdfx/my-document';
+
+    export function App() {
+      return (
+        <PDFViewer width="100%" height="600px">
+          <MyDocument />
+        </PDFViewer>
+      );
+    }
+    \`\`\`
+
+    Trigger a download with \`PDFDownloadLink\`:
+    \`\`\`tsx
+    import { PDFDownloadLink } from '@react-pdf/renderer';
+    import { MyDocument } from './components/pdfx/my-document';
+
+    export function DownloadButton() {
+      return (
+        <PDFDownloadLink document={<MyDocument />} fileName="document.pdf">
+          {({ loading }) => (loading ? 'Generating PDF...' : 'Download PDF')}
+        </PDFDownloadLink>
+      );
+    }
+    \`\`\`
+  `,
+  vite: dedent5`
+    ## Vite Notes
+
+    Works with both \`vite + react\` and \`vite + react-swc\` templates.
+
+    For client-side rendering, use \`PDFViewer\` or \`PDFDownloadLink\` from \`@react-pdf/renderer\`.
+
+    For server-side generation, use a separate Node.js server or Vite's server-side features.
+  `,
+  remix: dedent5`
+    ## Remix Notes
+
+    Use a resource route to serve PDFs:
+    \`\`\`tsx
+    // app/routes/pdf.tsx
+    import { renderToStream } from '@react-pdf/renderer';
+    import { MyDocument } from '~/components/pdfx/my-document';
+
+    export async function loader() {
+      const stream = await renderToStream(<MyDocument />);
+      return new Response(stream as unknown as ReadableStream, {
+        headers: { 'Content-Type': 'application/pdf' },
+      });
+    }
+    \`\`\`
+  `,
+  other: dedent5`
+    ## General Notes
+
+    \`@react-pdf/renderer\` works in any Node.js ≥ 18 environment.
+
+    - **Buffer output**: \`await renderToBuffer(<MyDocument />)\`
+    - **Stream output**: \`await renderToStream(<MyDocument />)\`
+    - **Client-side**: Use \`PDFViewer\` or \`PDFDownloadLink\` from \`@react-pdf/renderer\`
+  `
+};
+async function getInstallation(args) {
+  const pm = args.package_manager;
+  const fw = args.framework;
+  return textResponse(dedent5`
+    # PDFx Setup Guide: ${fw} + ${pm}
+
+    ## Step 1 — Install the peer dependency
+
+    \`\`\`bash
+    ${installCmd(pm, "@react-pdf/renderer")}
+    \`\`\`
+
+    ## Step 2 — Initialize PDFx in your project
+
+    \`\`\`bash
+    npx pdfx-cli init
+    \`\`\`
+
+    This creates \`pdfx.json\` in your project root and generates a theme file at \`src/lib/pdfx-theme.ts\`.
+
+    ## Step 3 — Add your first component
+
+    \`\`\`bash
+    npx pdfx-cli add heading text table
+    \`\`\`
+
+    Components are copied into \`src/components/pdfx/\`. You own the source — there is no runtime package dependency.
+
+    ## Step 4 — Or start with a complete document block
+
+    \`\`\`bash
+    npx pdfx-cli block add invoice-modern
+    \`\`\`
+
+    ${FRAMEWORK_NOTES[fw]}
+
+    ## Generated pdfx.json
+
+    \`\`\`json
+    {
+      "$schema": "https://pdfx.akashpise.dev/schema.json",
+      "componentDir": "./src/components/pdfx",
+      "blockDir": "./src/blocks/pdfx",
+      "registry": "https://pdfx.akashpise.dev/r",
+      "theme": "./src/lib/pdfx-theme.ts"
+    }
+    \`\`\`
+
+    ## pdfx.json Field Reference
+
+    All four fields are **required**. Relative paths must start with \`./\` or \`../\`.
+
+    | Field | Type | Description | Default |
+    |-------|------|-------------|---------|
+    | \`componentDir\` | string | Where individual components are installed | \`./src/components/pdfx\` |
+    | \`blockDir\` | string | Where full document blocks are installed | \`./src/blocks/pdfx\` |
+    | \`registry\` | string (URL) | Registry base URL (must start with http) | \`https://pdfx.akashpise.dev/r\` |
+    | \`theme\` | string | Path to your generated theme file | \`./src/lib/pdfx-theme.ts\` |
+
+    > **Non-interactive init (CI / AI agents):** pass \`--yes\` to accept all defaults:
+    > \`\`\`bash
+    > npx pdfx-cli init --yes
+    > \`\`\`
+
+    ## Troubleshooting
+
+    | Problem | Fix |
+    |---------|-----|
+    | TypeScript errors on \`@react-pdf/renderer\` | \`${installCmd(pm, "@react-pdf/types", true)}\` |
+    | "Cannot find module @/components/pdfx/..." | Run \`npx pdfx-cli@latest add <component>\` to install it |
+    | PDF renders blank | Ensure root returns \`<Document><Page>...</Page></Document>\` |
+    | "Invalid hook call" | PDFx components cannot use React hooks — pass data as props |
+
+    ---
+    Next: call \`get_audit_checklist\` to verify your setup is correct.
+  `);
+}
+
+// src/mcp/tools/search.ts
+import dedent6 from "dedent";
+import { z as z6 } from "zod";
+var searchRegistrySchema = z6.object({
+  query: z6.string().min(1).describe("Search query \u2014 matched against component name, title, and description"),
+  type: z6.enum(["all", "component", "block"]).optional().default("all").describe("Filter by item type (default: all)"),
+  limit: z6.number().int().positive().max(50).optional().default(20).describe("Maximum number of results to return (default: 20, max: 50)")
+});
+async function searchRegistry(args) {
+  const items = await fetchRegistryIndex();
+  const q = args.query.toLowerCase();
+  let pool = items;
+  if (args.type === "component") {
+    pool = items.filter((i) => i.type === "registry:ui");
+  } else if (args.type === "block") {
+    pool = items.filter((i) => i.type === "registry:block");
+  }
+  const scored = pool.map((item) => {
+    const name = item.name.toLowerCase();
+    const title = (item.title ?? "").toLowerCase();
+    const desc = (item.description ?? "").toLowerCase();
+    let score = 0;
+    if (name === q) score = 100;
+    else if (name.startsWith(q)) score = 80;
+    else if (name.includes(q)) score = 60;
+    else if (title.includes(q)) score = 40;
+    else if (desc.includes(q)) score = 20;
+    return { item, score };
+  }).filter((r) => r.score > 0).sort((a, b) => b.score - a.score).slice(0, args.limit);
+  if (scored.length === 0) {
+    return textResponse(dedent6`
+      # Search: "${args.query}"
+
+      No results found. Try a broader query or browse all items:
+      - \`list_components\` — see all 24 components
+      - \`list_blocks\` — see all 10 blocks
+    `);
+  }
+  const rows = scored.map(({ item }) => {
+    const typeLabel2 = item.type === "registry:ui" ? "component" : "block";
+    const addCmd = item.type === "registry:ui" ? `npx pdfx-cli add ${item.name}` : `npx pdfx-cli block add ${item.name}`;
+    return dedent6`
+      - **${item.name}** _(${typeLabel2})_ — ${item.description ?? "No description"}
+        \`${addCmd}\`
+    `;
+  });
+  const typeLabel = args.type === "all" ? "components + blocks" : args.type === "component" ? "components" : "blocks";
+  return textResponse(dedent6`
+    # Search: "${args.query}" — ${scored.length} result${scored.length === 1 ? "" : "s"} (${typeLabel})
+
+    ${rows.join("\n")}
+  `);
+}
+
+// src/mcp/tools/theme.ts
+import dedent7 from "dedent";
+import { z as z7 } from "zod";
+var getThemeSchema = z7.object({
+  theme: z7.enum(["professional", "modern", "minimal"]).describe("Theme preset name")
+});
+async function getTheme(args) {
+  const preset = themePresets[args.theme];
+  const { colors, typography, spacing, page } = preset;
+  return textResponse(dedent7`
+    # PDFx Theme: ${args.theme}
+
+    ## Colors
+    | Token | Value |
+    |-------|-------|
+    | foreground | \`${colors.foreground}\` |
+    | background | \`${colors.background}\` |
+    | primary | \`${colors.primary}\` |
+    | primaryForeground | \`${colors.primaryForeground}\` |
+    | accent | \`${colors.accent}\` |
+    | muted | \`${colors.muted}\` |
+    | mutedForeground | \`${colors.mutedForeground}\` |
+    | border | \`${colors.border}\` |
+    | destructive | \`${colors.destructive}\` |
+    | success | \`${colors.success}\` |
+    | warning | \`${colors.warning}\` |
+    | info | \`${colors.info}\` |
+
+    ## Typography
+
+    ### Body
+    - Font family: \`${typography.body.fontFamily}\`
+    - Font size: ${typography.body.fontSize}pt
+    - Line height: ${typography.body.lineHeight}
+
+    ### Headings
+    - Font family: \`${typography.heading.fontFamily}\`
+    - Font weight: ${typography.heading.fontWeight}
+    - Line height: ${typography.heading.lineHeight}
+    - h1: ${typography.heading.fontSize.h1}pt
+    - h2: ${typography.heading.fontSize.h2}pt
+    - h3: ${typography.heading.fontSize.h3}pt
+    - h4: ${typography.heading.fontSize.h4}pt
+    - h5: ${typography.heading.fontSize.h5}pt
+    - h6: ${typography.heading.fontSize.h6}pt
+
+    ## Spacing
+    - Page margins: top=${spacing.page.marginTop}pt · right=${spacing.page.marginRight}pt · bottom=${spacing.page.marginBottom}pt · left=${spacing.page.marginLeft}pt
+    - Section gap: ${spacing.sectionGap}pt
+    - Paragraph gap: ${spacing.paragraphGap}pt
+    - Component gap: ${spacing.componentGap}pt
+
+    ## Page
+    - Size: ${page.size}
+    - Orientation: ${page.orientation}
+
+    ## Apply This Theme
+    \`\`\`bash
+    npx pdfx-cli theme switch ${args.theme}
+    \`\`\`
+
+    ## Usage in Components
+    \`\`\`tsx
+    // Access theme values in a PDFx component
+    import type { PdfxTheme } from '@pdfx/shared';
+
+    interface Props {
+      theme: PdfxTheme;
+    }
+
+    export function MyComponent({ theme }: Props) {
+      return (
+        <View style={{ backgroundColor: theme.colors.background }}>
+          <Text style={{ color: theme.colors.foreground, fontSize: theme.typography.body.fontSize }}>
+            Content
+          </Text>
+        </View>
+      );
+    }
+    \`\`\`
+  `);
+}
+
+// src/mcp/index.ts
+var server = new Server(
+  { name: "pdfx", version: "1.0.0" },
+  { capabilities: { tools: {} } }
+);
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    {
+      name: "list_components",
+      description: "List all available PDFx PDF components with names and descriptions. Call this first to discover what components exist before adding any.",
+      inputSchema: zodToJsonSchema(listComponentsSchema)
+    },
+    {
+      name: "get_component",
+      description: "Get the full source code, files, and dependencies for a specific PDFx component. Use this to understand the API and props before using it in generated code.",
+      inputSchema: zodToJsonSchema(getComponentSchema)
+    },
+    {
+      name: "list_blocks",
+      description: "List all PDFx pre-built document blocks (complete invoice and report layouts ready to customize).",
+      inputSchema: zodToJsonSchema(listBlocksSchema)
+    },
+    {
+      name: "get_block",
+      description: "Get the full source code for a PDFx document block. Returns the complete layout code ready to customize for your use case.",
+      inputSchema: zodToJsonSchema(getBlockSchema)
+    },
+    {
+      name: "search_registry",
+      description: "Search PDFx components and blocks by name or description. Use this when you know what you need but not the exact item name.",
+      inputSchema: zodToJsonSchema(searchRegistrySchema)
+    },
+    {
+      name: "get_theme",
+      description: "Get the full design token values for a PDFx theme preset (professional, modern, or minimal). Use this to understand colors, typography, and spacing before customizing documents.",
+      inputSchema: zodToJsonSchema(getThemeSchema)
+    },
+    {
+      name: "get_installation",
+      description: "Get step-by-step PDFx setup instructions for a specific framework and package manager. Use this when setting up PDFx in a new project.",
+      inputSchema: zodToJsonSchema(getInstallationSchema)
+    },
+    {
+      name: "get_add_command",
+      description: "Get the exact CLI command string to add specific PDFx components or blocks to a project.",
+      inputSchema: zodToJsonSchema(getAddCommandSchema)
+    },
+    {
+      name: "get_audit_checklist",
+      description: "Get a post-generation checklist to verify PDFx is set up correctly. Call this after adding components or generating PDF document code.",
+      inputSchema: zodToJsonSchema(z8.object({}))
+    }
+  ]
+}));
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const args = request.params.arguments ?? {};
+  try {
+    switch (request.params.name) {
+      case "list_components":
+        return await listComponents();
+      case "get_component":
+        return await getComponent(getComponentSchema.parse(args));
+      case "list_blocks":
+        return await listBlocks();
+      case "get_block":
+        return await getBlock(getBlockSchema.parse(args));
+      case "search_registry":
+        return await searchRegistry(searchRegistrySchema.parse(args));
+      case "get_theme":
+        return await getTheme(getThemeSchema.parse(args));
+      case "get_installation":
+        return await getInstallation(getInstallationSchema.parse(args));
+      case "get_add_command":
+        return await getAddCommand(getAddCommandSchema.parse(args));
+      case "get_audit_checklist":
+        return await getAuditChecklist();
+      default:
+        return errorResponse(new Error(`Unknown tool: ${request.params.name}`));
+    }
+  } catch (error) {
+    return errorResponse(error);
+  }
+});
+export {
+  server
+};