@mindfiredigital/ignix-lite-engine 1.1.0

package/src/utils/a11y-types.ts

@@ -0,0 +1,15 @@
+export type IssueType = 'error' | 'warning'
+
+export interface A11yIssue {
+  type: IssueType
+  rule: string
+  element: string
+  message: string
+  fix: string
+  confidence?: number
+}
+
+export interface RuleResult {
+  ruleName: string
+  issues: A11yIssue[]
+}

package/src/utils/cosine.ts

@@ -0,0 +1,15 @@
+export function cosineSimilarity(a: number[], b: number[]): number {
+  let dot = 0
+  let magA = 0
+  let magB = 0
+
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i]
+    magA += a[i] * a[i]
+    magB += b[i] * b[i]
+  }
+
+  if (magA === 0 || magB === 0) return 0
+
+  return dot / (Math.sqrt(magA) * Math.sqrt(magB))
+}

package/src/utils/emmet-helpers.ts

@@ -0,0 +1,283 @@
+import emmet from 'emmet'
+
+// Expand Emmet shorthand to full HTML using the emmet npm package
+export function expandEmmet(emmetStr: string): string {
+  try {
+    return emmet(emmetStr)
+  } catch {
+    return `<!-- expand: ${emmetStr} -->`
+  }
+}
+
+// Maps HTML element names / web-component tag names → ignix-lite component names
+export const ELEMENT_TO_COMPONENT: Record<string, string> = {
+  // Native elements
+  button: 'button',
+  input: 'input',
+  textarea: 'textarea',
+  select: 'select',
+  form: 'form',
+  dialog: 'dialog',
+  details: 'accordion',
+  summary: 'accordion',
+  progress: 'progress',
+  meter: 'meter',
+  aside: 'alert',
+  mark: 'badge',
+  img: 'avatar',
+  article: 'card',
+  nav: 'navigation',
+  table: 'table',
+  pre: 'codeblock',
+  code: 'codeblock',
+  hr: 'divider',
+  label: 'input', // label wraps input/checkbox/radio
+  // Web components
+  'ix-tabs': 'tab',
+  'ix-dropdown': 'dropdown',
+  'ix-combobox': 'combobox',
+  'ix-tooltip': 'tooltip',
+  'ix-toast': 'toast'
+}
+
+// Skeleton heuristic: span with aria-busy or data-shape
+export const SKELETON_PATTERN = /span\[[^\]]*(?:aria-busy|data-shape)[^\]]*\]/i
+
+// Given an emmet string, return the unique set of ignix-lite component names hat the pattern uses.
+
+export function extractComponents(emmetStr: string): string[] {
+  const found = new Set<string>()
+
+  // Special case: skeleton uses span[aria-busy] or span[data-shape]
+  if (SKELETON_PATTERN.test(emmetStr)) {
+    found.add('skeleton')
+  }
+
+  // Special case: nav[aria-label=Breadcrumb] → breadcrumb
+  if (/nav\[[^\]]*breadcrumb/i.test(emmetStr)) {
+    found.add('breadcrumb')
+  } else if (/\bnav\b/.test(emmetStr)) {
+    found.add('navigation')
+  }
+
+  // Special case: label > input[type=checkbox] → checkbox
+  if (/input\[[^\]]*type=checkbox/i.test(emmetStr)) {
+    found.add('checkbox')
+  }
+
+  // Special case: label > input[type=radio] → radio
+  if (/input\[[^\]]*type=radio/i.test(emmetStr)) {
+    found.add('radio')
+  }
+
+  // Special case: section[data-grid] → grid (only when data-grid attr is present)
+  if (/section\[[^\]]*data-grid/i.test(emmetStr)) {
+    found.add('grid')
+  }
+
+  // General: extract all tag names from the emmet string
+  const tagPattern = /(?:^|[>+(])([a-z][a-z0-9-]*)/gi
+  let m: RegExpExecArray | null
+  while ((m = tagPattern.exec(emmetStr)) !== null) {
+    const tag = m[1].toLowerCase()
+    const component = ELEMENT_TO_COMPONENT[tag]
+    if (component) found.add(component)
+  }
+
+  return Array.from(found)
+}
+
+// Customizes standard Emmet shorthand by dynamically replacing text strings and visual intent attributes based on the user prompt description.
+
+function injectAttribute(emmetStr: string, attr: string, value: string): string {
+  if (emmetStr.includes(attr)) return emmetStr
+  const match = emmetStr.match(/^([a-z][a-z0-9-]*)(?:\[([^\]]*)\])?/i)
+  if (!match) return emmetStr
+  const tag = match[1]
+  const attrs = match[2] ? `${attr}=${value} ${match[2]}` : `${attr}=${value}`
+  return emmetStr.replace(/^([a-z][a-z0-9-]*)(?:\[[^\]]*\])?/i, `${tag}[${attrs}]`)
+}
+
+export function interpolateEmmet(
+  emmetStr: string,
+  description: string
+): string {
+  let result = emmetStr
+  const descLower = description.toLowerCase()
+
+  let intent = 'primary'
+  if (/\b(red|danger|delete|remove|destroy)\b/.test(descLower)) {
+    intent = 'danger'
+  } else if (/\b(green|success|work|done)\b/.test(descLower)) {
+    intent = 'success'
+  } else if (/\b(yellow|orange|warning|risky)\b/.test(descLower)) {
+    intent = 'warning'
+  } else if (/\b(ghost|secondary)\b/.test(descLower)) {
+    intent = 'ghost'
+  } else if (/\b(neutral|gray|grey)\b/.test(descLower)) {
+    intent = 'neutral'
+  }
+  result = result.replace(/data-intent=\?/g, `data-intent=${intent}`)
+
+  // Only override data-intent on semantic elements, not wrappers like label
+  const INTENT_ELEMENTS = /^(button|aside|mark|dialog|ix-tooltip|ix-toast)/
+  if (intent !== 'primary') {
+    result = result.replace(
+      /data-intent=(?:primary|neutral|ghost|success|warning|danger)/g,
+      (match, offset) => {
+        // Walk backwards to find the tag name to avoid injecting on label
+        const before = result.slice(0, offset)
+        const tagMatch = before.match(/([a-z][a-z0-9-]*)\[[^\]]*$/i)
+        if (tagMatch && !INTENT_ELEMENTS.test(tagMatch[1])) {
+          return match // leave unchanged
+        }
+        return `data-intent=${intent}`
+      }
+    )
+  }
+
+  let size = 'md'
+  if (/\b(large|lg|big)\b/.test(descLower)) {
+    size = 'lg'
+  } else if (/\b(small|sm|tiny)\b/.test(descLower)) {
+    size = 'sm'
+  }
+  result = result.replace(/data-size=\?/g, `data-size=${size}`)
+
+  let variant = 'solid'
+  if (/\b(outline|ghost|link)\b/.test(descLower)) {
+    variant = 'outline'
+  }
+  result = result.replace(/data-variant=\?/g, `data-variant=${variant}`)
+
+  // Recognize shape keywords: rectangular → rect, circle/round → circle
+  if (/\b(rect|rectangular|rectangle)\b/.test(descLower)) {
+    result = result.replace(/data-shape=(?:text|circle|\?)/g, 'data-shape=rect')
+  } else if (/\b(circle|round|circular)\b/.test(descLower)) {
+    result = result.replace(/data-shape=(?:text|rect|\?)/g, 'data-shape=circle')
+  }
+
+  if (/\b(loading|spinner|busy)\b/.test(descLower)) {
+    result = injectAttribute(result, 'aria-busy', 'true')
+  }
+  if (/\b(disabled|inactive)\b/.test(descLower)) {
+    result = injectAttribute(result, 'disabled', 'true')
+  }
+
+  const matches = [...description.matchAll(/['"]([^'"]+)['"]/g)]
+  const quotedStrings = matches
+    .map((m) => m[1].trim())
+    .filter((s) => s.length > 0)
+
+  if (quotedStrings.length > 0) {
+    let quoteIndex = 0
+
+    result = result.replace(/content(=\?|=""|=''|(?=[\]\s]|$))/g, () => {
+      if (quoteIndex < quotedStrings.length) {
+        return `content="${quotedStrings[quoteIndex++]}"`
+      }
+      return 'content=""'
+    })
+
+    result = result.replace(/title(=\?|=""|=''|(?=[\]\s]|$))/g, () => {
+      if (quoteIndex < quotedStrings.length) {
+        return `title="${quotedStrings[quoteIndex++]}"`
+      }
+      return 'title=""'
+    })
+
+    result = result.replace(/label(=\?|=""|=''|(?=[\]\s]|$))/g, () => {
+      if (quoteIndex < quotedStrings.length) {
+        return `label="${quotedStrings[quoteIndex++]}"`
+      }
+      return 'label=""'
+    })
+
+    const hasButtonMention = /\b(button|says|labeled|action|click)\b/i.test(
+      description
+    )
+
+    // Don't replace button labels when the only quoted string was already consumed as content=
+    const remainingQuotes = quotedStrings.slice(quoteIndex)
+    // Also skip if the emmet already has a populated content= attribute (e.g. from tooltip template)
+    // — in that case the quoted string belongs to content, not the button label
+    const hasPopulatedContent = /content="[^"]+"/i.test(result)
+    const shouldReplaceButton =
+      !hasPopulatedContent &&
+      (remainingQuotes.length >= 2 ||
+        (remainingQuotes.length === 1 && hasButtonMention))
+
+    if (shouldReplaceButton) {
+      const buttonRegex = /(button[^}]*)\{([^}]+)\}/g
+      const buttonMatches = [...result.matchAll(buttonRegex)]
+
+      if (buttonMatches.length > 0) {
+        const buttonLabel = remainingQuotes[remainingQuotes.length - 1]
+        result = result.replace(buttonRegex, (match, p1) => {
+          return `${p1}{${buttonLabel}}`
+        })
+      }
+    }
+
+
+
+    const textPlaceholderRegex = /\{(label|message|title|text)\}/gi
+    result = result.replace(textPlaceholderRegex, (match) => {
+      if (quoteIndex < quotedStrings.length) {
+        return `{${quotedStrings[quoteIndex++]}}`
+      }
+      return match
+    })
+
+    const labelRegex = /label\{([^}]+)\}/g
+    result = result.replace(labelRegex, (match) => {
+      if (quoteIndex < quotedStrings.length) {
+        return `label{${quotedStrings[quoteIndex++]}}`
+      }
+      return match
+    })
+
+    if (/label\{username\}/i.test(result)) {
+      result = result.replace(/type=email/g, 'type=text')
+    }
+  } else {
+    const labelMap: Record<string, string> = {
+      delete: 'Delete',
+      remove: 'Remove',
+      destroy: 'Destroy',
+      danger: 'Delete',
+      save: 'Save',
+      submit: 'Submit',
+      cancel: 'Cancel',
+      confirm: 'Confirm',
+      search: 'Search',
+      download: 'Download',
+      upload: 'Upload',
+      edit: 'Edit',
+      add: 'Add',
+      create: 'Create',
+      update: 'Update'
+    }
+    let extractedLabel = ''
+    for (const [key, val] of Object.entries(labelMap)) {
+      if (descLower.includes(key)) {
+        extractedLabel = val
+        break
+      }
+    }
+    if (!extractedLabel) {
+      const components = extractComponents(emmetStr)
+      if (components.length > 0) {
+        extractedLabel = components[0].charAt(0).toUpperCase() + components[0].slice(1)
+      } else {
+        extractedLabel = 'Button'
+      }
+    }
+    result = result.replace(/\{(label|Label|message|Message|title|Title|text|Text)\}/g, `{${extractedLabel}}`)
+  }
+
+  result = result.replace(/alt=\?/g, 'alt="User"')
+  result = result.replace(/src=\?/g, 'src="?"')
+
+  return result
+}

package/src/utils/intent-helpers.ts

@@ -0,0 +1,66 @@
+export const STOP_WORDS = new Set([
+  'with',
+  'for',
+  'and',
+  'the',
+  'you',
+  'can',
+  'from',
+  'this',
+  'that',
+  'your',
+  'want',
+  'need',
+  'show',
+  'give',
+  'nice',
+  'page',
+  'here',
+  'please',
+  'make',
+  'create',
+  'build',
+  'about',
+  'using',
+  'what',
+  'should',
+  'how'
+])
+
+export function tokenise(text: string): string[] {
+  return text
+    .toLowerCase()
+    .replace(/[^a-z0-9\s/]/g, ' ')
+    .split(/[\s/]+/)
+    .filter((w) => w.length > 1 && !STOP_WORDS.has(w))
+}
+
+export function editDistance(s1: string, s2: string): number {
+  const costs: number[] = []
+  for (let i = 0; i <= s1.length; i++) {
+    let lastValue = i
+    for (let j = 0; j <= s2.length; j++) {
+      if (i === 0) {
+        costs[j] = j
+      } else {
+        if (j > 0) {
+          let newValue = costs[j - 1]
+          if (s1.charAt(i - 1) !== s2.charAt(j - 1)) {
+            newValue = Math.min(Math.min(newValue, lastValue), costs[j]) + 1
+          }
+          costs[j - 1] = lastValue
+          lastValue = newValue
+        }
+      }
+    }
+    if (i > 0) costs[s2.length] = lastValue
+  }
+  return costs[s2.length]
+}
+
+export function isSimilar(w1: string, w2: string): boolean {
+  if (w1.length < 3 || w2.length < 3) return w1 === w2
+  // Typo tolerance: 1 edit for 3-5 chars, 2 edits for 6+ chars
+  const maxDistance = w1.length >= 6 && w2.length >= 6 ? 2 : 1
+  return editDistance(w1, w2) <= maxDistance
+}

package/src/utils/intent-parser.ts

@@ -0,0 +1,175 @@
+import { readFileSync, existsSync } from 'fs'
+import path from 'path'
+import { fileURLToPath } from 'url'
+import { tokenise, isSimilar } from './intent-helpers.js'
+
+export type IntentEntry = {
+  name: string
+  phrases: string[]
+  emmet: string
+  category: string
+}
+
+
+function parseIntents(raw: string): IntentEntry[] {
+  const entries: IntentEntry[] = []
+
+  // Find where the INTENTS block starts
+  const intentStart = raw.indexOf('INTENTS:')
+  if (intentStart === -1) return entries
+
+  const block = raw.slice(intentStart)
+  const lines = block.split(/\r?\n/)
+
+  let currentCategory = 'GENERAL'
+  let pendingPhrase: string | null = null
+
+  for (const raw_line of lines) {
+    const line = raw_line.trim()
+
+    // Category header: --- DESTROY / DANGER ---
+    if (line.startsWith('---') && line.endsWith('---')) {
+      currentCategory = line
+        .replace(/^-+\s*/, '')
+        .replace(/\s*-+$/, '')
+        .trim()
+      pendingPhrase = null
+      continue
+    }
+
+    // Skip meta comment line [caveman prompt → emmet...]
+    if (line.startsWith('[') && line.endsWith(']')) continue
+
+    // Skip NEVER DO section (starts with "never use")
+    if (line.startsWith('never ')) continue
+
+    // Skip blank lines and "→" alias lines (these are in NEVER DO)
+    if (line === '' || line.startsWith('→')) continue
+
+    // Emmet line: starts with "- "
+    if (line.startsWith('- ') && pendingPhrase !== null) {
+      const emmet = line.slice(2).trim()
+      entries.push({
+        name: pendingPhrase,
+        phrases: tokenise(pendingPhrase),
+        emmet,
+        category: currentCategory
+      })
+      pendingPhrase = null
+      continue
+    }
+
+    // Anything else is a caveman phrase (intent description)
+    if (!line.startsWith('-')) {
+      pendingPhrase = line
+    }
+  }
+
+  return entries
+}
+
+// ---- Resolve the api-full.txt path relative to this package root ----
+function loadIntents(): IntentEntry[] {
+  try {
+    const currentDir = path.dirname(fileURLToPath(import.meta.url))
+
+    // Try relative paths from current file structure (packages/mcp/src/utils/ or dist/utils/)
+    const path1 = path.resolve(currentDir, '../../../api-full.txt')
+    const path2 = path.resolve(currentDir, '../../api-full.txt')
+    const path3 = path.resolve(currentDir, '../../../../api-full.txt')
+
+    let txtPath = path1
+    if (existsSync(path1)) {
+      txtPath = path1
+    } else if (existsSync(path2)) {
+      txtPath = path2
+    } else if (existsSync(path3)) {
+      txtPath = path3
+    } else {
+      txtPath = path.resolve(process.cwd(), '../../api-full.txt')
+    }
+
+    const raw = readFileSync(txtPath, 'utf8')
+    return parseIntents(raw)
+  } catch {
+    return []
+  }
+}
+
+// Singleton - parsed once at server startup, stays in-memory (DC-13)
+let _cache: IntentEntry[] | null = null
+
+export function getIntentEntries(): IntentEntry[] {
+  if (!_cache) {
+    _cache = loadIntents()
+  }
+  return _cache
+}
+
+export type ScoreResult = {
+  score: number
+  density: number
+}
+
+// Score a single IntentEntry against the query, tolerating minor typos. eturns { score, density } for tie-breaking.
+
+export function scoreEntry(
+  entry: IntentEntry,
+  queryWords: string[]
+): ScoreResult {
+  let score = 0
+  const entryWords = new Set(entry.phrases)
+  let matchedCount = 0
+
+  for (const qw of queryWords) {
+    let matched = false
+    // 1. Exact match (+10)
+    if (entryWords.has(qw)) {
+      score += 10
+      matched = true
+    } else {
+      // 2. Fuzzy spelling similarity match (+8)
+      for (const ew of entryWords) {
+        if (isSimilar(qw, ew)) {
+          score += 8
+          matched = true
+          break
+        }
+      }
+      // 3. Substring match fallback (+4)
+      if (!matched) {
+        for (const ew of entryWords) {
+          if (ew.includes(qw) || qw.includes(ew)) {
+            score += 4
+            matched = true
+            break
+          }
+        }
+      }
+    }
+    if (matched) {
+      matchedCount++
+    }
+  }
+
+  // Bonus: category keyword overlap (supports fuzzy spelling matches)
+  const catWords = tokenise(entry.category)
+  for (const qw of queryWords) {
+    if (catWords.includes(qw)) {
+      score += 3
+    } else {
+      for (const cw of catWords) {
+        if (isSimilar(qw, cw)) {
+          score += 2
+          break
+        }
+      }
+    }
+  }
+
+  // Density = portion of the entry's phrases that were matched by the query
+  const density =
+    entry.phrases.length > 0 ? matchedCount / entry.phrases.length : 0
+
+  return { score, density }
+}

package/src/utils/tokenizer.ts

@@ -0,0 +1,7 @@
+import { encoding_for_model } from 'tiktoken'
+
+const encoder = encoding_for_model('gpt-4')
+
+export function getTokenCount(input: string): number {
+  return encoder.encode(input).length
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+    "extends": "../../tsconfig.base.json",
+    "compilerOptions": {
+        "target": "ES2022",
+        "module": "NodeNext",
+        "moduleResolution": "NodeNext",
+        "resolveJsonModule": true,
+        "esModuleInterop": true,
+        "strict": true,
+        "outDir": "./dist",
+        "composite": false
+    },
+    "include": [
+        "src/**/*",
+        "src/**/*.json"
+    ]
+}

package/tsup.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from 'tsup'
+
+export default defineConfig({
+    entry: ['src/index.ts'],
+    format: ['esm'],
+    dts: true,
+    clean: true,
+    sourcemap: true,
+    minify: false
+})