@mindfiredigital/ignix-lite-mcp 1.0.0 → 1.2.0

package/src/server.ts

@@ -1,3 +1,201 @@
-export function startServer() {
-  return 'MCP server is running'
+import { Server } from '@modelcontextprotocol/sdk/server/index.js'
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
+import {
+  ListToolsRequestSchema,
+  CallToolRequestSchema
+} from '@modelcontextprotocol/sdk/types.js'
+
+import { listComponents } from './tools/list-components.js'
+import { getManifest } from './tools/get-manifests.js'
+import { getEmmet } from './tools/get-emmet.js'
+import { validate } from './tools/validator.js'
+import { howToBuild } from './tools/intent-engine.js'
+import { apiContext } from './context/api-context.js'
+import { generateTheme } from './tools/generate-theme.js'
+import { checkA11y } from './tools/check-a11y.js'
+
+type ValidateArgs = {
+  html?: string
 }
+
+type IntentArgs = {
+  description?: string
+}
+
+type A11yArgs = {
+  html?: string
+}
+
+const server = new Server(
+  {
+    name: 'ignix-lite',
+    version: '2.0.0'
+  },
+
+  {
+    capabilities: {
+      tools: {}
+    }
+  }
+)
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    {
+      name: 'list_components',
+      description: 'List all ignix-lite components',
+      inputSchema: {
+        type: 'object',
+        properties: {}
+      }
+    },
+
+    {
+      name: 'get_manifest',
+      description: 'Get component manifest',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          name: {
+            type: 'string'
+          }
+        },
+
+        required: ['name']
+      }
+    },
+
+    {
+      name: 'get_emmet',
+      description: 'Get emmet pattern',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          name: {
+            type: 'string'
+          }
+        },
+        required: ['name']
+      }
+    },
+
+    {
+      name: 'validate',
+      description: 'Validate ignix-lite html',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          html: {
+            type: 'string'
+          }
+        },
+        required: ['html']
+      }
+    },
+
+    {
+      name: 'how_to_build',
+      description: 'Convert plain english to ignix-lite UI',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          description: {
+            type: 'string'
+          }
+        },
+        required: ['description']
+      }
+    },
+    {
+      name: 'generate_theme',
+
+      description: 'Generate ignix theme tokens',
+
+      inputSchema: {
+        type: 'object',
+
+        properties: {
+          prompt: {
+            type: 'string'
+          }
+        },
+
+        required: ['prompt']
+      }
+    },
+    {
+      name: 'check_a11y',
+
+      description: 'Check accessibility',
+
+      inputSchema: {
+        type: 'object',
+
+        properties: {
+          html: {
+            type: 'string'
+          }
+        },
+
+        required: ['html']
+      }
+    }
+  ]
+}))
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params
+
+  switch (name) {
+    case 'list_components':
+      return listComponents()
+
+    case 'get_manifest':
+      return getManifest(args)
+
+    case 'get_emmet':
+      return getEmmet(args)
+
+    case 'validate': {
+      const validateArgs = args as ValidateArgs
+
+      return validate(validateArgs.html ?? '')
+    }
+
+    case 'how_to_build': {
+      const intentArgs = args as IntentArgs
+
+      return await howToBuild(intentArgs.description ?? '')
+    }
+    case 'generate_theme': {
+      return generateTheme(args)
+    }
+    case 'check_a11y': {
+      const a11yArgs = args as A11yArgs
+
+      return checkA11y(a11yArgs.html ?? '')
+    }
+
+    default:
+      return {
+        content: [
+          {
+            type: 'text',
+
+            text: JSON.stringify({
+              error: `Unknown tool: ${name}`
+            })
+          }
+        ]
+      }
+  }
+})
+
+async function start() {
+  console.log('API loaded')
+  console.log(apiContext.length)
+  const transport = new StdioServerTransport()
+  await server.connect(transport)
+  console.log('Ignix MCP started')
+}
+start()

package/src/tools/build-index.ts

@@ -0,0 +1,55 @@
+import { readdirSync, readFileSync, writeFileSync } from 'fs'
+import { embedText } from './embedder.js'
+
+type Example = {
+  label?: string
+  emmet?: string
+  html?: string
+}
+
+interface Manifest {
+  component?: string
+  description?: string
+  element?: string
+  emmet?: string
+  states?: string[]
+  do?: string[]
+  dont?: string[]
+  examples?: Example[]
+}
+
+const files = readdirSync('src/manifests')
+
+const index = files
+  .filter((file) => file.endsWith('.json'))
+  .map((file) => {
+    const manifest: Manifest = JSON.parse(
+      readFileSync(`src/manifests/${file}`, 'utf8')
+    )
+
+    const searchable = [
+      manifest.component ?? '',
+      manifest.description ?? '',
+      manifest.element ?? '',
+      manifest.emmet ?? '',
+
+      ...(manifest.states ?? []),
+      ...(manifest.do ?? []),
+      ...(manifest.dont ?? []),
+      ...(manifest.examples ?? []).flatMap((x: Example) => [
+        x.label ?? '',
+        x.emmet ?? '',
+        x.html ?? ''
+      ])
+    ].join(' ')
+
+    return {
+      name: manifest.component,
+      emmet: manifest.emmet,
+      searchable,
+      embedding: embedText(searchable)
+    }
+  })
+
+writeFileSync('dist/vector-index.json', JSON.stringify(index, null, 2))
+console.log('Vector index built')

package/src/tools/check-a11y.ts

@@ -0,0 +1,106 @@
+import { parse } from 'node-html-parser'
+import type { MCPResponse } from '../types.js'
+import type { A11yIssue, RuleResult } from '../utils/a11y-types.js'
+import {
+  checkImages,
+  checkFormLabels,
+  checkEmptyLabels,
+  checkButtons,
+  checkLinks,
+  checkAriaStates,
+  checkDuplicateIds,
+  checkTabIndex,
+  checkHeadings,
+  checkTables,
+  checkDialogs,
+  checkRoles,
+  checkAutocomplete,
+  checkFocusStyle,
+  checkLang
+} from '../utils/a11y-rules.js'
+
+// Rule-specific confidence scores to avoid arbitrary hardcoding (addresses CodeRabbit feedback)
+const RULE_CONFIDENCES: Record<string, { error: number; warning: number }> = {
+  'WCAG 1.1.1 Non-text Content': { error: 0.99, warning: 0.80 },
+  'WCAG 1.3.1 Form Labels': { error: 0.98, warning: 0.78 },
+  'WCAG 2.4.6 Empty Labels': { error: 0.95, warning: 0.75 },
+  'WCAG 4.1.2 Button Names': { error: 0.99, warning: 0.80 },
+  'WCAG 2.4.4 Link Purpose': { error: 0.97, warning: 0.75 },
+  'WCAG 3.3.1 Error Identification': { error: 0.98, warning: 0.75 },
+  'WCAG 4.1.2 ARIA State Values': { error: 0.96, warning: 0.75 },
+  'WCAG 4.1.1 Parsing': { error: 0.99, warning: 0.80 },
+  'WCAG 2.1.1 Keyboard': { error: 0.95, warning: 0.75 },
+  'WCAG 2.4.6 Heading Hierarchy': { error: 0.95, warning: 0.75 },
+  'WCAG 1.3.1 Table Structure': { error: 0.97, warning: 0.75 },
+  'WCAG 4.1.2 Dialog Accessibility': { error: 0.98, warning: 0.75 },
+  'WCAG 4.1.2 ARIA Role Requirements': { error: 0.98, warning: 0.75 },
+  'WCAG 1.3.5 Input Purpose': { error: 0.95, warning: 0.75 },
+  'WCAG 2.4.7 Focus Visible': { error: 0.95, warning: 0.75 },
+  'WCAG 3.1.1 Language of Page': { error: 0.99, warning: 0.80 }
+}
+
+function getConfidenceForRule(
+  ruleName: string,
+  type: 'error' | 'warning'
+): number {
+  const conf = RULE_CONFIDENCES[ruleName]
+  if (conf) {
+    return type === 'error' ? conf.error : conf.warning
+  }
+  return type === 'error' ? 0.98 : 0.75
+}
+
+function computeScore(issues: A11yIssue[]): number {
+  const errors = issues.filter((i) => i.type === 'error').length
+  const warnings = issues.filter((i) => i.type === 'warning').length
+  return Math.max(0, 100 - errors * 10 - warnings * 3)
+}
+
+function getPassingRules(results: RuleResult[]): string[] {
+  return results.filter((r) => r.issues.length === 0).map((r) => r.ruleName)
+}
+
+export function checkA11y(html: string): MCPResponse {
+  const root = parse(html)
+
+  const results: RuleResult[] = [
+    checkImages(root),
+    checkFormLabels(root),
+    checkEmptyLabels(root),
+    checkButtons(root),
+    checkLinks(root),
+    checkAriaStates(root),
+    checkDuplicateIds(root),
+    checkTabIndex(root),
+    checkHeadings(root),
+    checkTables(root),
+    checkDialogs(root),
+    checkRoles(root),
+    checkAutocomplete(root),
+    checkFocusStyle(root),
+    checkLang(root)
+  ]
+
+  const rawIssues = results.flatMap((r) => r.issues)
+  const issues: A11yIssue[] = rawIssues.map((i) => ({
+    ...i,
+    confidence: getConfidenceForRule(i.rule, i.type)
+  }))
+  const passes = getPassingRules(results)
+  const score = computeScore(issues)
+
+  return {
+    content: [
+      {
+        type: 'text',
+        text: JSON.stringify({
+          score,
+          passes,
+          issues,
+          wcag: 'AA',
+          tokens_used: Math.min(60, 20 + issues.length * 3)
+        })
+      }
+    ]
+  }
+}

package/src/tools/embedder.ts

@@ -0,0 +1,18 @@
+const VOCAB_SIZE = 512
+
+export function embedText(text: string): number[] {
+  const vector = new Array(VOCAB_SIZE).fill(0)
+  const words = text
+    .toLowerCase()
+    .replace(/[^a-z0-9\s]/g, ' ')
+    .split(/\s+/)
+    .filter(Boolean)
+  words.forEach((word) => {
+    let hash = 0
+    for (let i = 0; i < word.length; i++) {
+      hash = (hash * 31 + word.charCodeAt(i)) % VOCAB_SIZE
+    }
+    vector[hash] += 1
+  })
+  return vector
+}

package/src/tools/generate-theme.ts

@@ -0,0 +1,42 @@
+import { z } from 'zod'
+import type { MCPResponse } from '../types.js'
+import { resolveTokens, buildCss } from './theme-tokens.js'
+
+const schema = z.object({ prompt: z.string().min(1) })
+
+export function generateTheme(args: unknown): MCPResponse {
+  const parsed = schema.safeParse(args)
+
+  if (!parsed.success) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({
+            error: 'Invalid input',
+            suggestion: 'Expected { prompt: string }',
+            tokens_used: 2
+          })
+        }
+      ]
+    }
+  }
+
+  const { prompt } = parsed.data
+  const tokens = resolveTokens(prompt.toLowerCase().trim())
+
+  return {
+    content: [
+      {
+        type: 'text',
+        text: JSON.stringify({
+          prompt,
+          primary: tokens.resolvedPrimary,
+          isDark: tokens.isDark,
+          css: buildCss(tokens),
+          tokens_used: 10
+        })
+      }
+    ]
+  }
+}

package/src/tools/get-emmet.ts

@@ -0,0 +1,64 @@
+import { z } from 'zod'
+import { manifests } from '../manifests/index.js'
+import type { MCPResponse } from '../types.js'
+
+const schema = z.object({
+  name: z.string()
+})
+
+export function getEmmet(args: unknown): MCPResponse {
+  const parsed = schema.safeParse(args)
+
+  if (!parsed.success) {
+    return {
+      content: [
+        {
+          type: 'text',
+
+          text: JSON.stringify({
+            error: 'Invalid input',
+
+            suggestion: 'Expected { name: string }',
+
+            tokens_used: 2
+          })
+        }
+      ]
+    }
+  }
+
+  const { name } = parsed.data
+
+  const manifest = manifests[name]
+
+  if (!manifest) {
+    return {
+      content: [
+        {
+          type: 'text',
+
+          text: JSON.stringify({
+            error: `Unknown component: ${name}`,
+            suggestion: 'Call list_components() first',
+            tokens_used: 2
+          })
+        }
+      ]
+    }
+  }
+
+  return {
+    content: [
+      {
+        type: 'text',
+
+        text: JSON.stringify({
+          component: manifest.component,
+          emmet: manifest.emmet,
+          tokens: manifest.tokens,
+          tokens_used: 3
+        })
+      }
+    ]
+  }
+}

package/src/tools/get-manifests.ts

@@ -0,0 +1,55 @@
+import { z } from 'zod'
+import { manifests } from '../manifests/index.js'
+import type { MCPResponse } from '../types.js'
+
+const schema = z.object({
+  name: z.string()
+})
+
+export function getManifest(args: unknown): MCPResponse {
+  const parsed = schema.safeParse(args)
+
+  if (!parsed.success) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({
+            error: 'Invalid input',
+            suggestion: 'Expected { name: string }',
+            tokens_used: 2
+          })
+        }
+      ]
+    }
+  }
+
+  const { name } = parsed.data
+
+  const manifest = manifests[name]
+
+  if (!manifest) {
+    return {
+      content: [
+        {
+          type: 'text',
+
+          text: JSON.stringify({
+            error: `Unknown component: ${name}`,
+            suggestion: 'Call list_components() first',
+            tokens_used: 2
+          })
+        }
+      ]
+    }
+  }
+
+  return {
+    content: [
+      {
+        type: 'text',
+        text: JSON.stringify(manifest)
+      }
+    ]
+  }
+}