@mindfiredigital/ignix-lite-engine 1.1.0

package/src/tools/build-index.ts

@@ -0,0 +1,43 @@
+import { readdirSync, readFileSync, writeFileSync } from 'fs'
+
+import { embedText } from './embedder.js'
+
+type Example = {
+  label?: string
+  emmet?: string
+  html?: string
+}
+
+const files = readdirSync('src/manifests')
+
+const index = files
+  .filter((file) => file.endsWith('.json'))
+  .map((file) => {
+    const 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,96 @@
+import { parse } from 'node-html-parser'
+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'
+
+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 auditA11y(html: string): { score: number; passes: string[]; issues: A11yIssue[]; wcag: string } {
+    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 {
+        score,
+        passes,
+        issues,
+        wcag: 'AA'
+    }
+}

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)
+      }
+    ]
+  }
+}

package/src/tools/handoff.ts

@@ -0,0 +1,302 @@
+import { parse, type HTMLElement } from 'node-html-parser'
+import { expandEmmet } from '../utils/emmet-helpers.js'
+import { getTokenCount } from '../utils/tokenizer.js'
+import type { MCPResponse } from '../types.js'
+
+export interface HandoffComponent {
+  selector: string
+  emmet: string
+  state: Record<string, string>
+  tokens: number
+}
+
+export interface HandoffEnvelope {
+  schema: 'ignix-lite-handoff'
+  version: '1.0'
+  id: string
+  timestamp: number
+  html: string
+  components: HandoffComponent[]
+  total_tokens: number
+  metadata?: Record<string, unknown>
+}
+
+const MAX_HANDOFFS = 100
+const handoffs = new Map<string, HandoffEnvelope>()
+
+function saveHandoff(id: string, envelope: HandoffEnvelope): void {
+  if (handoffs.size >= MAX_HANDOFFS) {
+    const oldestKey = handoffs.keys().next().value
+    if (oldestKey !== undefined) {
+      handoffs.delete(oldestKey)
+    }
+  }
+  handoffs.set(id, envelope)
+}
+
+function generateHandoffId(): string {
+  return 'hndff_' + Math.random().toString(36).substring(2, 15)
+}
+
+function extractState(element: HTMLElement): Record<string, string> {
+  const state: Record<string, string> = {}
+  const attrs = [
+    'data-intent',
+    'disabled',
+    'checked',
+    'open',
+    'aria-busy',
+    'aria-invalid',
+    'aria-selected',
+    'aria-expanded'
+  ]
+  for (const attr of attrs) {
+    const val = element.getAttribute(attr)
+    if (val !== undefined && val !== null) {
+      state[attr] = val === '' ? 'true' : val
+    }
+  }
+  return state
+}
+
+function getElementSelector(el: HTMLElement, root: HTMLElement): string {
+  const elementId = el.getAttribute('id')
+  if (elementId) {
+    return `#${elementId}`
+  }
+
+  const tag = el.tagName.toLowerCase()
+  const parent = el.parentNode as HTMLElement | null
+
+  if (!parent || parent === root || !parent.tagName) {
+    const siblings = (root.childNodes || []).filter(
+      (node): node is HTMLElement => node.nodeType === 1
+    )
+    const sameTagSiblings = siblings.filter(
+      (node) => node.tagName && node.tagName.toLowerCase() === tag
+    )
+    const index = Math.max(1, sameTagSiblings.indexOf(el) + 1)
+    return `${tag}:nth-of-type(${index})`
+  }
+
+  const siblings = (parent.childNodes || []).filter(
+    (node): node is HTMLElement => node.nodeType === 1
+  )
+  const sameTagSiblings = siblings.filter(
+    (node) => node.tagName && node.tagName.toLowerCase() === tag
+  )
+  const index = Math.max(1, sameTagSiblings.indexOf(el) + 1)
+
+  const parentSelector = getElementSelector(parent, root)
+  return `${parentSelector} > ${tag}:nth-of-type(${index})`
+}
+
+export function createHandoff(args: {
+  rendered_html: string
+  metadata?: Record<string, unknown>
+}): MCPResponse {
+  const { rendered_html, metadata } = args
+  const root = parse(rendered_html)
+
+  const id = generateHandoffId()
+  const timestamp = Date.now()
+  const components: HandoffComponent[] = []
+
+  const componentTags = [
+    'button',
+    'input',
+    'textarea',
+    'select',
+    'aside',
+    'mark',
+    'article',
+    'dialog',
+    'details',
+    'progress',
+    'meter',
+    'nav',
+    'hr',
+    'pre',
+    'table',
+    'ix-tabs',
+    'ix-dropdown',
+    'ix-combobox',
+    'ix-tooltip',
+    'ix-toast'
+  ]
+
+  const elements = root.querySelectorAll('*')
+  for (const el of elements) {
+    const tag = el.tagName.toLowerCase()
+    if (componentTags.includes(tag) || el.getAttribute('data-intent')) {
+      const selector = getElementSelector(el, root)
+
+      const outerHtml = el.outerHTML
+      const tokens = getTokenCount(outerHtml)
+      const state = extractState(el)
+
+      components.push({
+        selector,
+        emmet: outerHtml,
+        state,
+        tokens
+      })
+    }
+  }
+
+  const envelope: HandoffEnvelope = {
+    schema: 'ignix-lite-handoff',
+    version: '1.0',
+    id,
+    timestamp,
+    html: rendered_html,
+    components,
+    total_tokens: getTokenCount(rendered_html),
+    metadata
+  }
+
+  saveHandoff(id, envelope)
+
+  return {
+    content: [
+      {
+        type: 'text',
+        text: JSON.stringify({
+          handoff_id: id,
+          snapshot: {
+            schema: envelope.schema,
+            version: envelope.version,
+            id: envelope.id,
+            timestamp: envelope.timestamp,
+            components: envelope.components.map((c) => ({
+              selector: c.selector,
+              emmet: c.emmet,
+              state: c.state,
+              tokens: c.tokens
+            })),
+            total_tokens: envelope.total_tokens,
+            metadata: envelope.metadata
+          },
+          tokens_used: 10
+        })
+      }
+    ]
+  }
+}
+
+export interface HandoffChange {
+  selector: string
+  action: 'update' | 'add' | 'remove'
+  emmet?: string
+  html?: string
+}
+
+export function applyHandoff(args: {
+  handoff_id: string
+  changes: HandoffChange[]
+}): MCPResponse {
+  const { handoff_id, changes } = args
+  const envelope = handoffs.get(handoff_id)
+
+  if (!envelope) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({
+            error: `Handoff snapshot not found: ${handoff_id}`,
+            tokens_used: 5
+          })
+        }
+      ]
+    }
+  }
+
+  // Assert that change.html or change.emmet is present for add and update actions
+  for (const change of changes) {
+    if (change.action === 'update' || change.action === 'add') {
+      const hasHtml = change.html !== undefined && change.html !== null && change.html.trim() !== ''
+      const hasEmmet = change.emmet !== undefined && change.emmet !== null && change.emmet.trim() !== ''
+      if (!hasHtml && !hasEmmet) {
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify({
+                error: `Validation error: change for selector "${change.selector}" with action "${change.action}" must provide a non-empty "html" or "emmet" payload.`,
+                tokens_used: 5
+              })
+            }
+          ]
+        }
+      }
+    }
+  }
+
+  const root = parse(envelope.html)
+  let diffTokens = 0
+  const failedSelectors: string[] = []
+  const errors: string[] = []
+
+  const sortedChanges = [...changes].sort((a, b) => {
+    if (a.action === 'remove' && b.action !== 'remove') return 1
+    if (a.action !== 'remove' && b.action === 'remove') return -1
+    return 0
+  })
+
+  for (const change of sortedChanges) {
+    try {
+      const target = root.querySelector(change.selector)
+      if (!target) {
+        failedSelectors.push(change.selector)
+        continue
+      }
+
+      const changeContent =
+        change.html || (change.emmet ? expandEmmet(change.emmet) : '')
+      diffTokens += getTokenCount(changeContent || change.selector)
+
+      if (change.action === 'update') {
+        const newNode = parse(changeContent)
+        target.replaceWith(newNode)
+      } else if (change.action === 'add') {
+        const newNode = parse(changeContent)
+        target.appendChild(newNode)
+      } else if (change.action === 'remove') {
+        target.remove()
+      }
+    } catch (err: unknown) {
+      const message = err instanceof Error ? err.message : String(err)
+      errors.push(
+        `Failed to apply change on selector "${change.selector}": ${message}`
+      )
+    }
+  }
+
+  const updatedHtml = root.toString()
+  const fullTokens = getTokenCount(updatedHtml)
+  const savingsPct =
+    fullTokens > 0 ? Math.round((1 - diffTokens / fullTokens) * 100) : 0
+
+  envelope.html = updatedHtml
+  envelope.total_tokens = fullTokens
+  saveHandoff(handoff_id, envelope)
+
+  return {
+    content: [
+      {
+        type: 'text',
+        text: JSON.stringify({
+          updated_html: updatedHtml,
+          diff_tokens: diffTokens,
+          full_tokens: fullTokens,
+          savings_pct: Math.max(0, savingsPct),
+          failed_selectors:
+            failedSelectors.length > 0 ? failedSelectors : undefined,
+          errors: errors.length > 0 ? errors : undefined,
+          tokens_used: 15
+        })
+      }
+    ]
+  }
+}