@forgespace/branding-mcp 0.4.0

package/src/resources/brand-knowledge.ts

@@ -0,0 +1,60 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+
+const COLOR_THEORY = {
+  harmonies: {
+    complementary: 'Colors opposite on the color wheel. High contrast, vibrant.',
+    analogous: 'Colors adjacent on the wheel. Harmonious, low contrast.',
+    triadic: 'Three colors equally spaced (120 degrees). Balanced and colorful.',
+    'split-complementary': 'Base + two colors adjacent to its complement. Softer contrast.',
+    tetradic: 'Four colors forming a rectangle. Rich palette, needs balance.',
+    monochromatic: 'Single hue with varied lightness/saturation. Cohesive and elegant.',
+  },
+  psychology: {
+    red: 'Energy, passion, urgency. Use for CTAs and alerts.',
+    blue: 'Trust, stability, professionalism. Common in tech and finance.',
+    green: 'Growth, health, nature. Used in wellness and sustainability.',
+    purple: 'Creativity, luxury, wisdom. Premium and creative brands.',
+    orange: 'Enthusiasm, confidence, warmth. Energetic and approachable.',
+    yellow: 'Optimism, clarity, warmth. Attention-grabbing accents.',
+    black: 'Sophistication, power, elegance. Luxury and editorial.',
+    white: 'Simplicity, cleanliness, space. Minimalist design.',
+  },
+  accessibility: {
+    wcagAA: 'Minimum 4.5:1 contrast ratio for normal text',
+    wcagAALarge: 'Minimum 3:1 for large text (18px+ or 14px+ bold)',
+    wcagAAA: 'Enhanced 7:1 contrast ratio for normal text',
+  },
+};
+
+const TYPOGRAPHY_RULES = {
+  scales: {
+    'minor-second': { ratio: 1.067, use: 'Very tight, dense interfaces' },
+    'major-second': { ratio: 1.125, use: 'Compact, functional UIs' },
+    'minor-third': { ratio: 1.2, use: 'General purpose, most common' },
+    'major-third': { ratio: 1.25, use: 'Marketing, editorial content' },
+    'perfect-fourth': { ratio: 1.333, use: 'Bold hierarchies, headlines' },
+    'golden-ratio': { ratio: 1.618, use: 'Dramatic, artistic layouts' },
+  },
+  pairingPrinciples: [
+    'Contrast serif/sans-serif for heading/body distinction',
+    'Limit to 2-3 fonts maximum per project',
+    'Ensure x-height similarity for optical consistency',
+    'Match historical period and cultural context',
+  ],
+};
+
+export function registerBrandKnowledge(server: McpServer): void {
+  server.resource('brand-knowledge', 'brand://knowledge', async () => ({
+    contents: [
+      {
+        uri: 'brand://knowledge',
+        text: JSON.stringify(
+          { colorTheory: COLOR_THEORY, typographyRules: TYPOGRAPHY_RULES },
+          null,
+          2
+        ),
+        mimeType: 'application/json',
+      },
+    ],
+  }));
+}

package/src/resources/brand-templates.ts

@@ -0,0 +1,70 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+
+const TEMPLATES = [
+  {
+    id: 'tech-startup',
+    name: 'Tech Startup',
+    style: 'tech',
+    baseColor: '#6B4CE6',
+    harmony: 'complementary',
+    headingCategory: 'sans-serif',
+    bodyCategory: 'sans-serif',
+  },
+  {
+    id: 'luxury-brand',
+    name: 'Luxury Brand',
+    style: 'elegant',
+    baseColor: '#1A1A2E',
+    harmony: 'analogous',
+    headingCategory: 'serif',
+    bodyCategory: 'serif',
+  },
+  {
+    id: 'health-wellness',
+    name: 'Health & Wellness',
+    style: 'organic',
+    baseColor: '#2D6A4F',
+    harmony: 'analogous',
+    headingCategory: 'serif',
+    bodyCategory: 'sans-serif',
+  },
+  {
+    id: 'creative-agency',
+    name: 'Creative Agency',
+    style: 'bold',
+    baseColor: '#FF6B35',
+    harmony: 'triadic',
+    headingCategory: 'display',
+    bodyCategory: 'sans-serif',
+  },
+  {
+    id: 'fintech',
+    name: 'Fintech',
+    style: 'corporate',
+    baseColor: '#0052CC',
+    harmony: 'complementary',
+    headingCategory: 'sans-serif',
+    bodyCategory: 'sans-serif',
+  },
+  {
+    id: 'education',
+    name: 'Education',
+    style: 'playful',
+    baseColor: '#7C3AED',
+    harmony: 'split-complementary',
+    headingCategory: 'display',
+    bodyCategory: 'sans-serif',
+  },
+];
+
+export function registerBrandTemplates(server: McpServer): void {
+  server.resource('brand-templates', 'brand://templates', async () => ({
+    contents: [
+      {
+        uri: 'brand://templates',
+        text: JSON.stringify(TEMPLATES, null, 2),
+        mimeType: 'application/json',
+      },
+    ],
+  }));
+}

package/src/tools/create-brand-guidelines.ts

@@ -0,0 +1,94 @@
+import { z } from 'zod';
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { brandDocFormatSchema } from '../lib/branding-core/validators/token-schema.js';
+import type { BrandIdentity } from '../lib/types.js';
+import { logger } from '../lib/logger.js';
+
+function generateHtmlGuidelines(brand: BrandIdentity): string {
+  const { colors, typography } = brand;
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${brand.name} - Brand Guidelines</title>
+  <style>
+    body { font-family: '${typography.bodyFont}', sans-serif; max-width: 960px; margin: 0 auto; padding: 2rem; color: #1a1a1a; }
+    h1, h2, h3 { font-family: '${typography.headingFont}', sans-serif; }
+    .swatch { display: inline-block; width: 80px; height: 80px; border-radius: 8px; margin: 4px; }
+    .color-label { font-size: 12px; text-align: center; margin-top: 4px; }
+    .section { margin: 2rem 0; padding: 1.5rem; border: 1px solid #e0e0e0; border-radius: 8px; }
+  </style>
+</head>
+<body>
+  <h1>${brand.name} Brand Guidelines</h1>
+  ${brand.tagline ? `<p><em>${brand.tagline}</em></p>` : ''}
+
+  <div class="section">
+    <h2>Color Palette</h2>
+    <div>
+      <div><div class="swatch" style="background:${colors.primary.hex}"></div><div class="color-label">Primary<br>${colors.primary.hex}</div></div>
+      <div><div class="swatch" style="background:${colors.secondary.hex}"></div><div class="color-label">Secondary<br>${colors.secondary.hex}</div></div>
+      <div><div class="swatch" style="background:${colors.accent.hex}"></div><div class="color-label">Accent<br>${colors.accent.hex}</div></div>
+    </div>
+    <h3>Neutrals</h3>
+    <div>${colors.neutral.map((n) => `<div style="display:inline-block"><div class="swatch" style="background:${n.hex}"></div><div class="color-label">${n.name}<br>${n.hex}</div></div>`).join('')}</div>
+  </div>
+
+  <div class="section">
+    <h2>Typography</h2>
+    <p><strong>Heading:</strong> ${typography.headingFont}</p>
+    <p><strong>Body:</strong> ${typography.bodyFont}</p>
+    <p><strong>Mono:</strong> ${typography.monoFont}</p>
+    <h3>Type Scale</h3>
+    ${typography.steps.map((s) => `<p style="font-size:${s.size};line-height:${s.lineHeight};font-weight:${s.weight}">${s.name} — ${s.size}</p>`).join('\n    ')}
+  </div>
+
+  <div class="section">
+    <h2>Logo</h2>
+    ${brand.logo?.svg ? brand.logo.svg : '<p>Logo not generated</p>'}
+  </div>
+
+  <footer><p>Generated by @forgespace/branding-mcp</p></footer>
+</body>
+</html>`;
+}
+
+export function registerCreateBrandGuidelines(server: McpServer): void {
+  server.tool(
+    'create_brand_guidelines',
+    'Generate a brand guidelines document (HTML brand book) from a brand identity. Includes color swatches, typography samples, logo, and usage rules.',
+    {
+      brand: z.string().describe('Full BrandIdentity JSON'),
+      format: brandDocFormatSchema.optional().describe('Output format (html supported)'),
+    },
+    async ({ brand, format }) => {
+      try {
+        logger.info({ format }, 'Creating brand guidelines');
+        const brandData: BrandIdentity = JSON.parse(brand);
+
+        if (format === 'pdf') {
+          return {
+            content: [
+              {
+                type: 'text',
+                text: 'PDF generation requires pdfkit. Use HTML format or install optional dependencies.',
+              },
+            ],
+          };
+        }
+
+        const html = generateHtmlGuidelines(brandData);
+        return {
+          content: [{ type: 'text', text: html }],
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: 'text', text: `Error creating guidelines: ${message}` }],
+          isError: true,
+        };
+      }
+    }
+  );
+}

package/src/tools/export-design-tokens.ts

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import {
+  exportDesignTokens,
+  exportCssVariables,
+  exportTailwindPreset,
+  exportFigmaTokens,
+  exportReactTheme,
+  exportSassVariables,
+} from '../lib/branding-core/index.js';
+import { exportFormatSchema } from '../lib/branding-core/validators/token-schema.js';
+import type { BrandIdentity, ExportFormat } from '../lib/types.js';
+import { logger } from '../lib/logger.js';
+
+const EXPORTERS: Record<ExportFormat, (brand: BrandIdentity) => string | object> = {
+  json: exportDesignTokens,
+  css: exportCssVariables,
+  tailwind: exportTailwindPreset,
+  figma: exportFigmaTokens,
+  react: exportReactTheme,
+  sass: exportSassVariables,
+};
+
+export function registerExportDesignTokens(server: McpServer): void {
+  server.tool(
+    'export_design_tokens',
+    'Export a brand identity as design tokens in various formats: W3C JSON, CSS custom properties, Tailwind preset, Figma tokens, React theme, or Sass variables.',
+    {
+      brand: z.string().describe('Full BrandIdentity JSON (from generate_brand_identity output)'),
+      format: exportFormatSchema.describe('Export format'),
+    },
+    async ({ brand, format }) => {
+      try {
+        logger.info({ format }, 'Exporting design tokens');
+        const brandData: BrandIdentity = JSON.parse(brand);
+        const exporter = EXPORTERS[format];
+        const result = exporter(brandData);
+        const output = typeof result === 'string' ? result : JSON.stringify(result, null, 2);
+
+        return {
+          content: [{ type: 'text', text: output }],
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: 'text', text: `Error exporting tokens: ${message}` }],
+          isError: true,
+        };
+      }
+    }
+  );
+}

package/src/tools/generate-brand-assets.ts

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { generateFavicons, generateOgImage } from '../lib/branding-core/index.js';
+import type { BrandIdentity } from '../lib/types.js';
+import { logger } from '../lib/logger.js';
+
+const ogTemplateSchema = z.enum(['default', 'article', 'social']);
+
+export function registerGenerateBrandAssets(server: McpServer): void {
+  server.tool(
+    'generate_brand_assets',
+    'Generate brand assets (favicons, OG images) from an existing brand identity JSON.',
+    {
+      brand: z
+        .string()
+        .min(1)
+        .describe('JSON string of BrandIdentity from generate_brand_identity'),
+      ogTemplate: ogTemplateSchema
+        .optional()
+        .describe('OG image template: default, article, or social'),
+      ogTitle: z.string().max(200).optional().describe('Custom OG image title'),
+      ogSubtitle: z.string().max(200).optional().describe('Custom OG image subtitle'),
+    },
+    async ({ brand: brandJson, ogTemplate, ogTitle, ogSubtitle }) => {
+      try {
+        const brand: BrandIdentity = JSON.parse(brandJson);
+        logger.info({ brandName: brand.name }, 'Generating brand assets');
+
+        const iconSvg = brand.logo?.variants?.icon ?? brand.logo?.svg ?? '';
+        const favicons = iconSvg ? generateFavicons(iconSvg, brand.colors.primary.hex) : null;
+
+        const ogImage = generateOgImage(brand, ogTemplate ?? 'default', ogTitle, ogSubtitle);
+
+        const result = { favicons, ogImage };
+
+        return {
+          content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: 'text', text: `Error generating assets: ${message}` }],
+          isError: true,
+        };
+      }
+    }
+  );
+}

package/src/tools/generate-brand-identity.ts

@@ -0,0 +1,115 @@
+import { z } from 'zod';
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import {
+  generateColorPalette,
+  generateTypographySystem,
+  generateSpacingScale,
+  generateShadowSystem,
+  generateBorderSystem,
+  generateMotionSystem,
+  generateGradientSystem,
+  generateSvgLogo,
+  defaultLogoConfig,
+} from '../lib/branding-core/index.js';
+import {
+  brandStyleSchema,
+  colorHarmonySchema,
+  colorThemeSchema,
+  fontCategorySchema,
+  hexColorSchema,
+  typeScaleRatioSchema,
+} from '../lib/branding-core/validators/token-schema.js';
+import type { BrandIdentity, BrandStyle, FontCategory } from '../lib/types.js';
+import { logger } from '../lib/logger.js';
+
+const STYLE_DEFAULTS: Record<BrandStyle, { heading: FontCategory; body: FontCategory }> = {
+  minimal: { heading: 'sans-serif', body: 'sans-serif' },
+  bold: { heading: 'display', body: 'sans-serif' },
+  elegant: { heading: 'serif', body: 'serif' },
+  playful: { heading: 'display', body: 'sans-serif' },
+  corporate: { heading: 'sans-serif', body: 'sans-serif' },
+  tech: { heading: 'sans-serif', body: 'monospace' },
+  organic: { heading: 'serif', body: 'sans-serif' },
+  retro: { heading: 'display', body: 'serif' },
+};
+
+export function registerGenerateBrandIdentity(server: McpServer): void {
+  server.tool(
+    'generate_brand_identity',
+    'Generate a complete brand identity including colors, typography, spacing, and logo. Provide a brand name and style preferences to get a cohesive identity system.',
+    {
+      brandName: z.string().min(1).max(100).describe('Brand name'),
+      industry: z.string().min(1).max(100).describe('Industry or sector (e.g. "tech", "health")'),
+      style: brandStyleSchema.describe('Visual style direction'),
+      tagline: z.string().max(200).optional().describe('Brand tagline'),
+      baseColor: hexColorSchema.optional().describe('Base color preference'),
+      harmony: colorHarmonySchema.optional().describe('Color harmony type'),
+      theme: colorThemeSchema.optional().describe('Light/dark/both'),
+      headingCategory: fontCategorySchema.optional().describe('Heading font category'),
+      bodyCategory: fontCategorySchema.optional().describe('Body font category'),
+      scaleRatio: typeScaleRatioSchema.optional().describe('Typography scale ratio'),
+    },
+    async ({
+      brandName,
+      industry,
+      style,
+      tagline,
+      baseColor,
+      harmony,
+      theme,
+      headingCategory,
+      bodyCategory,
+      scaleRatio,
+    }) => {
+      try {
+        logger.info({ brandName, industry, style }, 'Generating brand identity');
+
+        const defaults = STYLE_DEFAULTS[style];
+        const colors = generateColorPalette(baseColor, harmony ?? 'complementary', theme);
+        const typography = generateTypographySystem(
+          headingCategory ?? defaults.heading,
+          bodyCategory ?? defaults.body,
+          scaleRatio ?? 'major-third'
+        );
+        const spacing = generateSpacingScale();
+        const shadows = generateShadowSystem(colors.primary.hex, theme);
+        const borders = generateBorderSystem(style);
+        const motion = generateMotionSystem(style);
+        const gradients = generateGradientSystem(colors, style);
+        const logoConfig = {
+          ...defaultLogoConfig(brandName, colors.primary.hex),
+          font: typography.headingFont,
+          style,
+        };
+        const logo = generateSvgLogo(logoConfig);
+
+        const identity: BrandIdentity = {
+          id: `brand_${Date.now().toString(36)}`,
+          name: brandName,
+          tagline,
+          industry,
+          style,
+          colors,
+          typography,
+          spacing,
+          shadows,
+          borders,
+          motion,
+          gradients,
+          logo,
+          createdAt: new Date().toISOString(),
+        };
+
+        return {
+          content: [{ type: 'text', text: JSON.stringify(identity, null, 2) }],
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: 'text', text: `Error generating brand: ${message}` }],
+          isError: true,
+        };
+      }
+    }
+  );
+}

package/src/tools/generate-color-palette.ts

@@ -0,0 +1,43 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { generateColorPalette } from '../lib/branding-core/index.js';
+import {
+  colorHarmonySchema,
+  colorThemeSchema,
+  hexColorSchema,
+} from '../lib/branding-core/validators/token-schema.js';
+import { logger } from '../lib/logger.js';
+
+export function registerGenerateColorPalette(server: McpServer): void {
+  server.tool(
+    'generate_color_palette',
+    'Generate a harmonious color palette with WCAG contrast validation. Supports complementary, analogous, triadic, split-complementary, tetradic, and monochromatic harmonies.',
+    {
+      baseColor: hexColorSchema
+        .optional()
+        .describe('Base hex color to build palette from (e.g. #6B4CE6)'),
+      harmony: colorHarmonySchema.optional().describe('Color harmony type'),
+      theme: colorThemeSchema.optional().describe('Light, dark, or both neutral scales'),
+    },
+    async ({ baseColor, harmony, theme }) => {
+      try {
+        logger.info({ baseColor, harmony, theme }, 'Generating color palette');
+        const palette = generateColorPalette(baseColor, harmony, theme);
+
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify(palette, null, 2),
+            },
+          ],
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: 'text', text: `Error generating palette: ${message}` }],
+          isError: true,
+        };
+      }
+    }
+  );
+}

package/src/tools/generate-typography-system.ts

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { generateTypographySystem } from '../lib/branding-core/index.js';
+import {
+  fontCategorySchema,
+  typeScaleRatioSchema,
+} from '../lib/branding-core/validators/token-schema.js';
+import { logger } from '../lib/logger.js';
+
+export function registerGenerateTypographySystem(server: McpServer): void {
+  server.tool(
+    'generate_typography_system',
+    'Generate a typography system with font pairing, modular type scale, and line heights. Uses curated font pairings for visual harmony.',
+    {
+      headingCategory: fontCategorySchema.optional().describe('Font category for headings'),
+      bodyCategory: fontCategorySchema.optional().describe('Font category for body text'),
+      scaleRatio: typeScaleRatioSchema.optional().describe('Modular scale ratio'),
+      baseSize: z.number().min(12).max(24).optional().describe('Base font size in pixels'),
+    },
+    async ({ headingCategory, bodyCategory, scaleRatio, baseSize }) => {
+      try {
+        logger.info({ headingCategory, bodyCategory, scaleRatio }, 'Generating typography system');
+        const system = generateTypographySystem(
+          headingCategory,
+          bodyCategory,
+          scaleRatio,
+          baseSize
+        );
+
+        return {
+          content: [{ type: 'text', text: JSON.stringify(system, null, 2) }],
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: 'text', text: `Error generating typography: ${message}` }],
+          isError: true,
+        };
+      }
+    }
+  );
+}

package/src/tools/refine-brand-element.ts

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { interpretFeedback, applyIntent } from '../lib/branding-core/index.js';
+import type { BrandIdentity } from '../lib/types.js';
+import type { InterpreterStrategy } from '../lib/branding-core/index.js';
+import { loadConfig } from '../lib/config.js';
+import { logger } from '../lib/logger.js';
+
+export function registerRefineBrandElement(server: McpServer): void {
+  server.tool(
+    'refine_brand_element',
+    'Refine a specific element of an existing brand identity using natural language feedback. Uses AI interpretation when available, keyword matching as fallback.',
+    {
+      brand: z.string().describe('Full BrandIdentity JSON'),
+      element: z.enum(['colors', 'typography', 'spacing']).describe('Element to refine'),
+      feedback: z
+        .string()
+        .describe(
+          'Natural language feedback (e.g. "make it feel more premium and understated", "use serif headings with dramatic scale")'
+        ),
+      strategy: z
+        .enum(['keyword', 'ai', 'auto'])
+        .optional()
+        .describe(
+          'Interpretation strategy: keyword (fast), ai (Claude API), auto (ai if key available)'
+        ),
+    },
+    async ({ brand, element, feedback, strategy }) => {
+      try {
+        logger.info({ element, feedback, strategy }, 'Refining brand element');
+        const brandData: BrandIdentity = JSON.parse(brand);
+        const config = loadConfig();
+
+        const intent = await interpretFeedback(
+          feedback,
+          element,
+          brandData,
+          (strategy as InterpreterStrategy) ?? 'auto',
+          { anthropicApiKey: config.anthropicApiKey }
+        );
+
+        const refined = applyIntent(brandData, intent);
+
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify(
+                { ...refined, _interpretation: { strategy: strategy ?? 'auto', ...intent } },
+                null,
+                2
+              ),
+            },
+          ],
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: 'text', text: `Error refining element: ${message}` }],
+          isError: true,
+        };
+      }
+    }
+  );
+}

package/src/tools/validate-brand-consistency.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { validateBrandConsistency } from '../lib/branding-core/index.js';
+import type { BrandIdentity } from '../lib/types.js';
+import { logger } from '../lib/logger.js';
+
+export function registerValidateBrandConsistency(server: McpServer): void {
+  server.tool(
+    'validate_brand_consistency',
+    'Validate a brand identity for completeness, WCAG contrast compliance, and typography best practices. Returns a score (0-100) and actionable issues.',
+    {
+      brand: z.string().describe('Full BrandIdentity JSON to validate'),
+    },
+    async ({ brand }) => {
+      try {
+        logger.info('Validating brand consistency');
+        const brandData: BrandIdentity = JSON.parse(brand);
+        const result = validateBrandConsistency(brandData);
+
+        return {
+          content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: 'text', text: `Error validating brand: ${message}` }],
+          isError: true,
+        };
+      }
+    }
+  );
+}

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["ES2022"],
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts"]
+}