typedump 0.1.0

package/dist/chunk-D7LJ3A3P.js

@@ -0,0 +1,254 @@
+#!/usr/bin/env node
+
+// src/data.ts
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var raw = require2("../data/fonts-data.json");
+var fonts = raw.families.filter((f) => f.name && f.variants?.length);
+function findFont(name) {
+  const lower = name.toLowerCase();
+  return fonts.find((f) => f.name.toLowerCase() === lower) ?? fonts.find((f) => f.name.toLowerCase().includes(lower));
+}
+
+// src/search.ts
+function search(query, filters) {
+  const q = query.toLowerCase();
+  let results = fonts;
+  if (filters?.collection) {
+    results = results.filter((f) => f.collection === filters.collection);
+  }
+  if (filters?.useCase) {
+    const uc = filters.useCase.toLowerCase();
+    results = results.filter((f) => f.useCases?.some((u) => u.toLowerCase().includes(uc)));
+  }
+  if (filters?.category) {
+    const cat = filters.category.toLowerCase();
+    results = results.filter((f) => f.category?.some((c) => c.toLowerCase().includes(cat)));
+  }
+  if (filters?.isVariable !== void 0) {
+    results = results.filter((f) => f.isVariable === filters.isVariable);
+  }
+  if (filters?.language) {
+    const lang = filters.language.toLowerCase();
+    results = results.filter((f) => f.languages?.some((l) => l.toLowerCase().includes(lang)));
+  }
+  if (!q) return results;
+  return results.filter(
+    (f) => f.name.toLowerCase().includes(q) || f.foundry?.toLowerCase().includes(q) || f.useCases?.some((u) => u.toLowerCase().includes(q)) || f.styleTags?.some((t) => t.toLowerCase().includes(q)) || f.category?.some((c) => c.toLowerCase().includes(q))
+  );
+}
+
+// src/suggest.ts
+var USE_CASE_KEYWORDS = {
+  "Interface": ["ui", "interface", "app", "dashboard", "product", "saas", "admin", "system", "neutral", "clean"],
+  "Interface Warm": ["warm", "friendly", "humanist", "readable"],
+  "Editorial / Ecommerce": ["ecommerce", "shop", "store", "editorial", "magazine", "blog", "article", "brand", "landing"],
+  "Editorial": ["editorial", "reading", "longform", "text", "body", "newspaper", "book", "serif"],
+  "Code / Data": ["code", "mono", "monospace", "data", "terminal", "developer", "programming", "table"],
+  "Tech": ["tech", "technical", "inktrap", "space"],
+  "Brand Headline": ["headline", "heading", "brand", "logo", "title", "display", "marketing"],
+  "Poster": ["poster", "bold", "big", "impactful", "fatface", "condensed", "attention"],
+  "Culture": ["culture", "zine", "art", "independent", "underground", "print", "identity"],
+  "Tech / Digital": ["pixel", "digital", "retro", "screen", "game", "matrix", "cyber"],
+  "Handwritten / Script": ["script", "handwritten", "calligraphy", "wedding", "personal", "organic"],
+  "Experimental": ["experimental", "avant-garde", "brutal", "weird", "unique", "provocative", "art"]
+};
+function scoreFont(font, keywords) {
+  let score = 0;
+  const lk = keywords.map((k) => k.toLowerCase());
+  for (const uc of font.useCases ?? []) {
+    const ucLower = uc.toLowerCase();
+    const ucKeywords = USE_CASE_KEYWORDS[uc] ?? [];
+    if (lk.some((k) => ucLower.includes(k) || ucKeywords.includes(k))) score += 4;
+    if (lk.some((k) => ucKeywords.some((uk) => uk.includes(k)))) score += 2;
+  }
+  for (const tag of font.styleTags ?? []) {
+    if (lk.some((k) => tag.toLowerCase().includes(k))) score += 2;
+  }
+  for (const cat of font.category ?? []) {
+    if (lk.some((k) => cat.toLowerCase().includes(k))) score += 1;
+  }
+  if (lk.some((k) => font.name.toLowerCase().includes(k))) score += 3;
+  if (font.isVariable) score += 1;
+  return score;
+}
+function suggest(description, count = 5) {
+  const keywords = description.toLowerCase().split(/\s+/).filter((k) => k.length > 2);
+  return fonts.map((f) => ({ font: f, score: scoreFont(f, keywords) })).filter(({ score }) => score > 0).sort((a, b) => b.score - a.score).slice(0, count).map(({ font }) => font);
+}
+
+// src/similar.ts
+function similarity(a, b) {
+  if (a.name === b.name) return -1;
+  let score = 0;
+  const sharedUseCases = a.useCases?.filter((u) => b.useCases?.includes(u)) ?? [];
+  score += sharedUseCases.length * 4;
+  const sharedTags = a.styleTags?.filter((t) => b.styleTags?.includes(t)) ?? [];
+  score += sharedTags.length * 2;
+  const sharedCats = a.category?.filter((c) => b.category?.includes(c)) ?? [];
+  score += sharedCats.length * 2;
+  if (a.collection === b.collection) score += 1;
+  if (a.isVariable === b.isVariable) score += 1;
+  return score;
+}
+function findSimilar(name, count = 5) {
+  const source = findFont(name);
+  if (!source) return [];
+  return fonts.map((f) => ({ font: f, score: similarity(source, f) })).filter(({ score }) => score > 0).sort((a, b) => b.score - a.score).slice(0, count).map(({ font }) => font);
+}
+
+// src/pair.ts
+var HEADLINE_USE_CASES = ["Brand Headline", "Poster", "Culture", "Tech / Digital"];
+var BODY_USE_CASES = ["Interface", "Editorial / Ecommerce", "Editorial", "Interface Warm"];
+function isHeadline(f) {
+  return f.useCases?.some((u) => HEADLINE_USE_CASES.includes(u));
+}
+function isBody(f) {
+  return f.useCases?.some((u) => BODY_USE_CASES.includes(u));
+}
+function contrastScore(h, b) {
+  let score = 0;
+  const hCats = h.category ?? [];
+  const bCats = b.category ?? [];
+  if (hCats.some((c) => c.includes("Serif")) && bCats.some((c) => c.includes("Sans"))) score += 3;
+  if (hCats.some((c) => c.includes("Sans")) && bCats.some((c) => c.includes("Serif"))) score += 3;
+  if (hCats.some((c) => c.includes("Sans")) && bCats.some((c) => c.includes("Sans"))) score += 1;
+  if (b.isVariable) score += 2;
+  if (h.foundry && b.foundry && h.foundry === b.foundry) score -= 1;
+  return score;
+}
+function pairFonts(anchorName, count = 3) {
+  const anchor = anchorName ? findFont(anchorName) : void 0;
+  const pairings = [];
+  if (anchor && isBody(anchor)) {
+    const headlines = fonts.filter(isHeadline);
+    headlines.map((h) => ({ h, score: contrastScore(h, anchor) })).sort((a, b) => b.score - a.score).slice(0, count).forEach(({ h }) => {
+      pairings.push({
+        headline: h,
+        body: anchor,
+        rationale: buildRationale(h, anchor)
+      });
+    });
+  } else if (anchor && isHeadline(anchor)) {
+    const bodies = fonts.filter(isBody);
+    bodies.map((b) => ({ b, score: contrastScore(anchor, b) })).sort((a, b) => b.score - a.score).slice(0, count).forEach(({ b }) => {
+      pairings.push({
+        headline: anchor,
+        body: b,
+        rationale: buildRationale(anchor, b)
+      });
+    });
+  } else {
+    const headlines = fonts.filter(isHeadline).slice(0, 10);
+    const bodies = fonts.filter((f) => isBody(f) && f.isVariable).slice(0, 10);
+    for (const h of headlines.slice(0, count)) {
+      const best = bodies.map((b) => ({ b, score: contrastScore(h, b) })).sort((a, b) => b.score - a.score)[0];
+      if (best) {
+        pairings.push({ headline: h, body: best.b, rationale: buildRationale(h, best.b) });
+      }
+    }
+  }
+  return pairings.slice(0, count);
+}
+function buildRationale(h, b) {
+  const hStyle = h.styleTags?.[0] ?? h.category?.[0] ?? "display";
+  const bStyle = b.styleTags?.[0] ?? b.category?.[0] ?? "text";
+  return `${h.name} (${hStyle.toLowerCase()}) as headline, ${b.name} (${bStyle.toLowerCase()}) as body \u2014 ${h.isVariable || b.isVariable ? "both support variable weights" : "good contrast in style"}.`;
+}
+
+// src/getCode.ts
+function pickVariant(font) {
+  return font.variants.find((v) => v.isVariable) ?? font.variants.find((v) => v.weight === 400 && !v.isItalic) ?? font.variants[0];
+}
+function woff2(variant) {
+  return variant.filename.replace(/\.(ttf|otf)$/, ".woff2");
+}
+function cssVarName(name) {
+  return name.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+}
+function jsVarName(name) {
+  return name.split(/\s+/).map((w, i) => i === 0 ? w.toLowerCase() : w[0].toUpperCase() + w.slice(1).toLowerCase()).join("").replace(/[^a-zA-Z0-9]/g, "");
+}
+function getCode(fontName, stack) {
+  const font = findFont(fontName);
+  if (!font) return `Font "${fontName}" not found in TypeDump.`;
+  const variant = pickVariant(font);
+  const file = woff2(variant);
+  const wghtAxis = variant.variableAxes?.find((a) => a.tag === "wght");
+  const weightRange = wghtAxis ? `${wghtAxis.min} ${wghtAxis.max}` : String(variant.weight);
+  const cssVar = cssVarName(font.name);
+  const jsVar = jsVarName(font.name);
+  if (stack === "css") {
+    return `/* 1. Copy font file to your project */
+/* cp ./node_modules/typedump/fonts/${file} ./public/fonts/ */
+
+@font-face {
+  font-family: '${font.name}';
+  src: url('/fonts/${file}') format('woff2');
+  font-weight: ${weightRange};
+  font-style: normal;
+  font-display: swap;
+}
+
+:root {
+  --font-${cssVar}: '${font.name}', ${font.category?.includes("Mono") ? "monospace" : font.category?.includes("Serif") ? "serif" : "sans-serif"};
+}
+
+body {
+  font-family: var(--font-${cssVar});
+}`;
+  }
+  if (stack === "nextjs") {
+    return `// app/fonts.ts
+import localFont from 'next/font/local'
+
+export const ${jsVar} = localFont({
+  src: '../node_modules/typedump/fonts/${file}',
+  variable: '--font-${cssVar}',
+  weight: '${weightRange}',
+  display: 'swap',
+})
+
+// app/layout.tsx
+import { ${jsVar} } from './fonts'
+
+export default function RootLayout({ children }: { children: React.ReactNode }) {
+  return (
+    <html lang="en" className={\`\${${jsVar}.variable}\`}>
+      <body style={{ fontFamily: 'var(--font-${cssVar})' }}>{children}</body>
+    </html>
+  )
+}`;
+  }
+  if (stack === "tailwind") {
+    return `// tailwind.config.ts
+import type { Config } from 'tailwindcss'
+
+const config: Config = {
+  theme: {
+    extend: {
+      fontFamily: {
+        '${cssVar}': ['var(--font-${cssVar})', ${font.category?.includes("Mono") ? "'monospace'" : font.category?.includes("Serif") ? "'serif'" : "'sans-serif'"}],
+      },
+    },
+  },
+}
+export default config
+
+// Usage in className:
+// <p className="font-${cssVar}">Your text</p>
+
+// Note: pair with Next.js setup above to inject the CSS variable`;
+  }
+  return "";
+}
+
+export {
+  fonts,
+  findFont,
+  search,
+  suggest,
+  findSimilar,
+  pairFonts,
+  getCode
+};

package/dist/index.d.ts

@@ -0,0 +1,59 @@
+interface VariableAxis {
+    name: string;
+    tag: string;
+    min: number;
+    max: number;
+    default: number;
+}
+interface FontVariant {
+    filename: string;
+    weight: number;
+    styleName: string;
+    isItalic: boolean;
+    isVariable: boolean;
+    variableAxes?: VariableAxis[];
+    openTypeFeatures?: string[];
+}
+interface FontFamily {
+    id: string;
+    name: string;
+    collection: 'Text' | 'Display' | 'Brutal';
+    category: string[];
+    styleTags: string[];
+    useCases: string[];
+    languages: string[];
+    foundry: string;
+    isVariable: boolean;
+    downloadLink?: string;
+    description?: string;
+    licenseInfo?: string;
+    variants: FontVariant[];
+}
+type CodeStack = 'css' | 'nextjs' | 'tailwind';
+
+declare const fonts: FontFamily[];
+declare function findFont(name: string): FontFamily | undefined;
+
+interface SearchFilters {
+    collection?: 'Text' | 'Display' | 'Brutal';
+    useCase?: string;
+    category?: string;
+    isVariable?: boolean;
+    language?: string;
+}
+declare function search(query: string, filters?: SearchFilters): FontFamily[];
+
+declare function suggest(description: string, count?: number): FontFamily[];
+
+declare function findSimilar(name: string, count?: number): FontFamily[];
+
+interface FontPairing {
+    headline: FontFamily;
+    body: FontFamily;
+    rationale: string;
+}
+declare function pairFonts(anchorName?: string, count?: number): FontPairing[];
+
+declare function getCode(fontName: string, stack: CodeStack): string;
+
+export { type CodeStack, type FontFamily, type FontPairing, type FontVariant, type SearchFilters, type VariableAxis, findFont, findSimilar, fonts, getCode, pairFonts, search, suggest };

package/dist/index.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+import {
+  findFont,
+  findSimilar,
+  fonts,
+  getCode,
+  pairFonts,
+  search,
+  suggest
+} from "./chunk-D7LJ3A3P.js";
+export {
+  findFont,
+  findSimilar,
+  fonts,
+  getCode,
+  pairFonts,
+  search,
+  suggest
+};

package/dist/mcp/server.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/mcp/server.js

@@ -0,0 +1,177 @@
+#!/usr/bin/env node
+import {
+  findFont,
+  findSimilar,
+  getCode,
+  pairFonts,
+  search,
+  suggest
+} from "../chunk-D7LJ3A3P.js";
+
+// src/mcp/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+var server = new Server(
+  { name: "typedump", version: "0.1.0" },
+  { capabilities: { tools: {} } }
+);
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    {
+      name: "search_fonts",
+      description: "Search TypeDump font catalog by name, style, use case, or category. Returns matching fonts with metadata.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          query: { type: "string", description: "Search query (name, style, tag)" },
+          collection: { type: "string", enum: ["Text", "Display", "Brutal"], description: "Filter by collection" },
+          useCase: { type: "string", description: "Filter by use case: Interface, Editorial, Ecommerce, Code / Data, Brand Headline, Poster, Culture, Tech / Digital, Handwritten / Script, Experimental" },
+          isVariable: { type: "boolean", description: "Filter variable fonts only" }
+        }
+      }
+    },
+    {
+      name: "get_font",
+      description: "Get full details for a specific font: variants, variable axes, OpenType features, use cases, download info.",
+      inputSchema: {
+        type: "object",
+        required: ["name"],
+        properties: {
+          name: { type: "string", description: "Font family name" }
+        }
+      }
+    },
+    {
+      name: "suggest_font",
+      description: 'Suggest fonts for a use case described in natural language. E.g. "neutral sans for a fintech dashboard" or "bold display for a culture zine".',
+      inputSchema: {
+        type: "object",
+        required: ["description"],
+        properties: {
+          description: { type: "string", description: "What the font needs to do or feel like" },
+          count: { type: "number", description: "How many suggestions to return (default 5)" }
+        }
+      }
+    },
+    {
+      name: "find_similar",
+      description: "Find fonts visually or stylistically similar to a given font.",
+      inputSchema: {
+        type: "object",
+        required: ["name"],
+        properties: {
+          name: { type: "string", description: "Font name to find similar fonts for" },
+          count: { type: "number", description: "How many results (default 5)" }
+        }
+      }
+    },
+    {
+      name: "pair_fonts",
+      description: "Suggest headline + body font pairings. Optionally anchor to a font you already want to use.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          anchor: { type: "string", description: "A font you already want to use (will suggest what pairs with it)" },
+          count: { type: "number", description: "How many pairings to suggest (default 3)" }
+        }
+      }
+    },
+    {
+      name: "get_code",
+      description: "Get ready-to-use code for a font. Returns @font-face CSS, Next.js localFont config, or Tailwind fontFamily config.",
+      inputSchema: {
+        type: "object",
+        required: ["name", "stack"],
+        properties: {
+          name: { type: "string", description: "Font family name" },
+          stack: { type: "string", enum: ["css", "nextjs", "tailwind"], description: "Target stack" }
+        }
+      }
+    }
+  ]
+}));
+server.setRequestHandler(CallToolRequestSchema, async (req) => {
+  const { name } = req.params;
+  const args = req.params.arguments ?? {};
+  try {
+    if (name === "search_fonts") {
+      const results = search(args.query ?? "", {
+        collection: args.collection,
+        useCase: args.useCase,
+        isVariable: args.isVariable
+      });
+      const summary = results.slice(0, 20).map(
+        (f) => `\u2022 ${f.name} [${f.collection}] \u2014 ${f.useCases?.join(", ")} | ${f.category?.join(", ")}${f.isVariable ? " \xB7 variable" : ""}`
+      ).join("\n");
+      return { content: [{ type: "text", text: results.length === 0 ? "No fonts found matching that query." : `Found ${results.length} font${results.length === 1 ? "" : "s"}:
+
+${summary}` }] };
+    }
+    if (name === "get_font") {
+      const font = findFont(args.name);
+      if (!font) return { content: [{ type: "text", text: `Font "${args.name}" not found.` }] };
+      const axes = font.variants.find((v) => v.isVariable)?.variableAxes;
+      const features = font.variants[0]?.openTypeFeatures;
+      const text = [
+        `**${font.name}**`,
+        `Collection: ${font.collection}`,
+        `Category: ${font.category?.join(", ")}`,
+        `Use cases: ${font.useCases?.join(", ")}`,
+        `Style tags: ${font.styleTags?.join(", ") || "\u2014"}`,
+        `Foundry: ${font.foundry}`,
+        `Variable: ${font.isVariable ? "Yes" : "No"}`,
+        `Languages: ${font.languages?.join(", ")}`,
+        axes?.length ? `Variable axes: ${axes.map((a) => `${a.name} (${a.tag}) ${a.min}\u2013${a.max}`).join(", ")}` : null,
+        features?.length ? `OpenType features: ${features.slice(0, 8).join(", ")}` : null,
+        `Variants: ${font.variants.map((v) => v.styleName).join(", ")}`
+      ].filter(Boolean).join("\n");
+      return { content: [{ type: "text", text }] };
+    }
+    if (name === "suggest_font") {
+      const results = suggest(args.description ?? "", args.count ?? 5);
+      if (!results.length) return { content: [{ type: "text", text: "No matching fonts found for that description." }] };
+      const text = `Top ${results.length} suggestions for "${args.description}":
+
+` + results.map(
+        (f, i) => `${i + 1}. **${f.name}** [${f.collection}]
+   Use cases: ${f.useCases?.join(", ")}
+   ${f.category?.join(", ")}${f.isVariable ? " \xB7 variable" : ""} \xB7 ${f.styleTags?.slice(0, 3).join(", ")}`
+      ).join("\n\n");
+      return { content: [{ type: "text", text }] };
+    }
+    if (name === "find_similar") {
+      const results = findSimilar(args.name, args.count ?? 5);
+      if (!results.length) return { content: [{ type: "text", text: `No similar fonts found for "${args.name}".` }] };
+      const text = `Fonts similar to **${args.name}**:
+
+` + results.map(
+        (f) => `\u2022 ${f.name} [${f.collection}] \u2014 ${f.useCases?.join(", ")} | ${f.styleTags?.slice(0, 3).join(", ")}`
+      ).join("\n");
+      return { content: [{ type: "text", text }] };
+    }
+    if (name === "pair_fonts") {
+      const pairings = pairFonts(args.anchor, args.count ?? 3);
+      if (!pairings.length) return { content: [{ type: "text", text: "Could not generate pairings." }] };
+      const text = `Font pairings${args.anchor ? ` with ${args.anchor}` : ""}:
+
+` + pairings.map(
+        (p, i) => `${i + 1}. Headline: **${p.headline.name}** \xB7 Body: **${p.body.name}**
+   ${p.rationale}`
+      ).join("\n\n");
+      return { content: [{ type: "text", text }] };
+    }
+    if (name === "get_code") {
+      const code = getCode(args.name, args.stack);
+      return { content: [{ type: "text", text: code }] };
+    }
+    return { content: [{ type: "text", text: `Unknown tool: ${name}` }] };
+  } catch (err) {
+    return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }] };
+  }
+});
+var transport = new StdioServerTransport();
+await server.connect(transport);