@mindfiredigital/ignix-lite-mcp 1.2.0 → 1.4.0

package/src/tools/intent-engine.ts

@@ -1,197 +0,0 @@
-import { searchIndex } from './search-index.js'
-import { getIntentEntries, scoreEntry } from '../utils/intent-parser.js'
-import { getTokenCount } from '../utils/tokenizer.js'
-import { tokenise } from '../utils/intent-helpers.js'
-import {
-  expandEmmet,
-  extractComponents,
-  interpolateEmmet
-} from '../utils/emmet-helpers.js'
-
-import type { IntentEntry } from '../utils/intent-parser.js'
-
-// ─── Layer 1: api-full.txt INTENTS lookup ───────────────────────────────────
-
-type IntentMatch = {
-  name: string
-  emmet: string
-  score: number
-  source: 'intent-table' | 'vector-index'
-}
-
-const LAYER1_THRESHOLD = 8 // minimum score to trust an intent-table hit
-
-function searchIntentTable(description: string): IntentMatch | null {
-  const entries = getIntentEntries()
-  if (entries.length === 0) return null
-
-  const queryWords = tokenise(description)
-
-  // Find all matches meeting the threshold
-  const candidates: {
-    entry: IntentEntry
-    score: number
-    density: number
-    components: string[]
-  }[] = []
-  let bestSingle: (IntentMatch & { density: number }) | null = null
-
-  for (const entry of entries) {
-    const { score, density } = scoreEntry(entry, queryWords)
-    if (score >= LAYER1_THRESHOLD) {
-      const components = extractComponents(entry.emmet)
-      candidates.push({ entry, score, density, components })
-
-      const isBetter =
-        !bestSingle ||
-        score > bestSingle.score ||
-        (score === bestSingle.score && density > bestSingle.density)
-      if (isBetter) {
-        bestSingle = {
-          name: entry.name,
-          emmet: entry.emmet,
-          score,
-          density,
-          source: 'intent-table'
-        }
-      }
-    }
-  }
-
-  // If a single template matches with exceptionally high score, trust it directly
-  if (bestSingle && bestSingle.score >= 18) {
-    return bestSingle
-  }
-
-  // Check if the user explicitly requested stitching using conjunction words (and, plus, +, comma)
-  const isStitchRequested =
-    /\b(and|plus|\+)\b/i.test(description) || description.includes(',')
-
-  // Otherwise, check if we can stitch multiple distinct components together (synthesis)
-  if (isStitchRequested && candidates.length >= 2) {
-    // Sort candidates by score (descending)
-    candidates.sort((a, b) => b.score - a.score || b.density - a.density)
-
-    const selected: typeof candidates = []
-    const usedComponents = new Set<string>()
-
-    for (const c of candidates) {
-      // Check if this candidate is disjoint from the already selected components
-      const hasOverlap = c.components.some((comp) => usedComponents.has(comp))
-      if (!hasOverlap) {
-        selected.push(c)
-        c.components.forEach((comp) => usedComponents.add(comp))
-      }
-    }
-
-    // If we gathered at least 2 distinct templates, stitch them!
-    if (selected.length >= 2) {
-      // Re-sort selected in the order they appear in the user description to look natural
-      selected.sort((a, b) => {
-        const indexA = description
-          .toLowerCase()
-          .indexOf(tokenise(a.entry.name)[0])
-        const indexB = description
-          .toLowerCase()
-          .indexOf(tokenise(b.entry.name)[0])
-        return indexA - indexB
-      })
-
-      const combinedEmmet = selected.map((s) => s.entry.emmet).join('+')
-      const totalScore = selected.reduce((sum, s) => sum + s.score, 0)
-
-      return {
-        name: selected.map((s) => s.entry.name).join(' and '),
-        emmet: combinedEmmet,
-        score: totalScore,
-        source: 'intent-table'
-      }
-    }
-  }
-
-  return bestSingle
-}
-
-// ─── Layer 2: vector-index fallback ─────────────────────────────────────────
-
-function searchVectorLayer(description: string): IntentMatch | null {
-  const results = searchIndex(description)
-  if (results.length === 0) return null
-  const top = results[0]
-  return {
-    name: top.name,
-    emmet: top.emmet,
-    score: top.score,
-    source: 'vector-index'
-  }
-}
-
-// ─── Public: howToBuild ──────────────────────────────────────────────────────
-
-export async function howToBuild(description: string) {
-  let cleanDesc = description.trim()
-  if (cleanDesc.startsWith('{') && cleanDesc.endsWith('}')) {
-    try {
-      const parsed = JSON.parse(cleanDesc)
-      if (parsed && typeof parsed.description === 'string') {
-        cleanDesc = parsed.description
-      } else if (parsed && typeof parsed.text === 'string') {
-        cleanDesc = parsed.text
-      }
-    } catch {
-      // Ignore parsing errors, keep original string
-    }
-  }
-
-  // Layer 1 — fast, deterministic, hand-crafted intent table
-  let match = searchIntentTable(cleanDesc)
-
-  // Layer 2 — vector index fallback for novel / unknown queries
-  if (!match) {
-    match = searchVectorLayer(cleanDesc)
-  }
-
-  if (!match) {
-    return {
-      content: [
-        {
-          type: 'text',
-          text: JSON.stringify({
-            emmet: '',
-            html: '',
-            components_used: [],
-            confidence: 0,
-            tokens: 0,
-            tokens_used: 15,
-            source: 'no-match',
-            suggestion:
-              'Call list_components() to see all available components, or try a different description.'
-          })
-        }
-      ]
-    }
-  }
-
-  // Apply dynamic interpolation to customize labels, types, and colors on the fly
-  const emmet = interpolateEmmet(match.emmet, cleanDesc)
-  const components_used = extractComponents(emmet)
-
-  const confidence = Math.min(1, match.score / 40)
-
-  return {
-    content: [
-      {
-        type: 'text',
-        text: JSON.stringify({
-          emmet,
-          html: expandEmmet(emmet),
-          components_used,
-          confidence: Number(confidence.toFixed(2)),
-          tokens: getTokenCount(emmet),
-          tokens_used: 15,
-          source: match.source // tells caller which layer matched
-        })
-      }
-    ]
-  }
-}

package/src/tools/list-components.ts

@@ -1,20 +0,0 @@
-import { manifests } from '../manifests/index.js'
-
-import type { MCPResponse } from '../types.js'
-
-export function listComponents(): MCPResponse {
-  const components = Object.keys(manifests).sort()
-
-  return {
-    content: [
-      {
-        type: 'text',
-        text: JSON.stringify({
-          components,
-          count: components.length,
-          tokens_used: components.length
-        })
-      }
-    ]
-  }
-}

package/src/tools/search-index.ts

@@ -1,66 +0,0 @@
-import path from 'path'
-import { readFileSync, existsSync } from 'fs'
-import { fileURLToPath } from 'url'
-import { embedText } from './embedder.js'
-import { cosineSimilarity } from '../utils/cosine.js'
-
-type IndexItem = {
-  name: string
-  emmet: string
-  searchable: string
-  embedding: number[]
-}
-
-const __filename = fileURLToPath(import.meta.url)
-const __dirname = path.dirname(__filename)
-
-let _index: IndexItem[] | null = null
-
-function loadIndex(): IndexItem[] {
-  if (_index) return _index
-  const indexPath = path.resolve(__dirname, '../../dist/vector-index.json')
-  if (!existsSync(indexPath)) {
-    console.warn(
-      `[search-index] dist/vector-index.json not found at: ${indexPath} - run pnpm build:index`
-    )
-    _index = []
-    return _index
-  }
-  try {
-    _index = JSON.parse(readFileSync(indexPath, 'utf8'))
-  } catch (err) {
-    console.error(`[search-index] Failed to load index from ${indexPath}:`, err)
-    _index = []
-  }
-  return _index!
-}
-
-export function searchIndex(description: string) {
-  const index = loadIndex()
-  const queryEmbedding = embedText(description)
-
-  const words = description.toLowerCase().split(/\s+/)
-  const ranked = index
-    .map((item) => {
-      const similarity = cosineSimilarity(queryEmbedding, item.embedding)
-      let boost = 0
-      const searchable = item.searchable.toLowerCase()
-
-      words.forEach((word) => {
-        if (item.name.toLowerCase() === word) {
-          boost += 2
-        } else if (item.name.toLowerCase().includes(word)) {
-          boost += 1
-        }
-        if (searchable.includes(word)) {
-          boost += 0.3
-        }
-      })
-      return {
-        ...item,
-        score: similarity + boost
-      }
-    })
-    .sort((a, b) => b.score - a.score)
-  return ranked.slice(0, 3)
-}

package/src/tools/theme-palette.ts

@@ -1,65 +0,0 @@
-export interface ColorEntry {
-  primary: string
-  contrast: string
-}
-
-export const PALETTE: Record<string, ColorEntry> = {
-  red: { primary: '#ef4444', contrast: '#ffffff' },
-  orange: { primary: '#f97316', contrast: '#ffffff' },
-  amber: { primary: '#f59e0b', contrast: '#111827' },
-  yellow: { primary: '#eab308', contrast: '#111827' },
-  lime: { primary: '#84cc16', contrast: '#111827' },
-  green: { primary: '#22c55e', contrast: '#ffffff' },
-  emerald: { primary: '#10b981', contrast: '#ffffff' },
-  teal: { primary: '#14b8a6', contrast: '#ffffff' },
-  cyan: { primary: '#06b6d4', contrast: '#111827' },
-  sky: { primary: '#0ea5e9', contrast: '#111827' },
-  blue: { primary: '#3b82f6', contrast: '#ffffff' },
-  indigo: { primary: '#6366f1', contrast: '#ffffff' },
-  violet: { primary: '#8b5cf6', contrast: '#ffffff' },
-  purple: { primary: '#a855f7', contrast: '#ffffff' },
-  fuchsia: { primary: '#d946ef', contrast: '#ffffff' },
-  pink: { primary: '#ec4899', contrast: '#ffffff' },
-  rose: { primary: '#f43f5e', contrast: '#ffffff' },
-  cyberpunk: { primary: '#ec4899', contrast: '#ffffff' },
-  neon: { primary: '#d946ef', contrast: '#ffffff' },
-  eco: { primary: '#10b981', contrast: '#ffffff' },
-  forest: { primary: '#0f766e', contrast: '#ffffff' },
-  coffee: { primary: '#78350f', contrast: '#ffffff' },
-  ocean: { primary: '#0284c7', contrast: '#ffffff' },
-  sunset: { primary: '#f97316', contrast: '#ffffff' },
-  midnight: { primary: '#3730a3', contrast: '#ffffff' },
-  lavender: { primary: '#8b5cf6', contrast: '#ffffff' },
-  coral: { primary: '#f43f5e', contrast: '#ffffff' },
-  slate: { primary: '#64748b', contrast: '#ffffff' },
-  gold: { primary: '#d97706', contrast: '#111827' },
-  silver: { primary: '#94a3b8', contrast: '#111827' }
-}
-
-export function expandHex(hex: string): string {
-  const h = hex.replace('#', '')
-  return h.length === 3 ? '#' + h[0] + h[0] + h[1] + h[1] + h[2] + h[2] : hex
-}
-
-export function contrastFor(hex6: string): string {
-  const h = hex6.replace('#', '')
-  const r = parseInt(h.substring(0, 2), 16)
-  const g = parseInt(h.substring(2, 4), 16)
-  const b = parseInt(h.substring(4, 6), 16)
-  return (r * 299 + g * 587 + b * 114) / 1000 > 165 ? '#111827' : '#ffffff'
-}
-
-export function resolveColor(query: string): ColorEntry {
-  const hexMatch = query.match(/#([0-9a-fA-F]{6}|[0-9a-fA-F]{3})\b/)
-  if (hexMatch) {
-    const primary = expandHex(hexMatch[0])
-    return { primary, contrast: contrastFor(primary) }
-  }
-
-  const sorted = Object.keys(PALETTE).sort((a, b) => b.length - a.length)
-  for (const name of sorted) {
-    if (query.includes(name)) return PALETTE[name]
-  }
-
-  return { primary: '#6366f1', contrast: '#ffffff' }
-}

package/src/tools/theme-tokens.ts

@@ -1,176 +0,0 @@
-import { resolveColor } from './theme-palette.js'
-
-export interface ThemeTokens {
-  primary: string
-  primaryHover: string
-  primaryContrast: string
-  primaryBg: string
-
-  danger: string
-  dangerText: string
-  dangerBg: string
-
-  warning: string
-  warningBg: string
-
-  success: string
-  successBg: string
-
-  infoBg: string
-  neutral: string
-  divider: string
-
-  surface: string
-  surfaceRaised: string
-
-  text: string
-  textMuted: string
-  border: string
-
-  radius: string
-  radiusLg: string
-  badgeRadius: string
-
-  skeletonBg: string
-  skeletonShimmer: string
-
-  gradientStart: string
-  gradientEnd: string
-  gradientBgEnd: string
-
-  isDark: boolean
-  resolvedPrimary: string
-  resolvedContrast: string
-}
-
-export function resolveTokens(query: string): ThemeTokens {
-  const { primary, contrast } = resolveColor(query)
-
-  const isDark =
-    query.includes('dark') ||
-    query.includes('night') ||
-    query.includes('midnight') ||
-    query.includes('cyberpunk') ||
-    query.includes('dim')
-
-  const sharp =
-    query.includes('sharp') ||
-    query.includes('flat') ||
-    query.includes('square')
-  const round =
-    query.includes('round') || query.includes('pill') || query.includes('soft')
-
-  return {
-    resolvedPrimary: primary,
-    resolvedContrast: contrast,
-    isDark,
-
-    primary,
-    primaryHover: isDark
-      ? 'color-mix(in srgb, var(--ix-primary) 75%, white)'
-      : 'color-mix(in srgb, var(--ix-primary) 85%, black)',
-    primaryContrast: isDark
-      ? 'color-mix(in srgb, var(--ix-primary) 40%, white)'
-      : contrast,
-    primaryBg: isDark
-      ? 'color-mix(in srgb, var(--ix-primary) 20%, #0f172a)'
-      : 'color-mix(in srgb, var(--ix-primary) 15%, white)',
-
-    danger: '#ef4444',
-    dangerText: isDark ? '#f87171' : '#ef4444',
-    dangerBg: isDark ? '#3f1d1d' : '#fee2e2',
-
-    warning: isDark ? '#fbbf24' : '#f59e0b',
-    warningBg: isDark ? '#3f2e05' : '#fef3c7',
-
-    success: '#22c55e',
-    successBg: isDark ? '#052e16' : '#dcfce7',
-
-    infoBg: isDark ? '#1e293b' : '#f3f4f6',
-    neutral: isDark ? '#9ca3af' : '#6b7280',
-    divider: isDark ? '#475569' : '#9ca3af',
-
-    surface: isDark ? '#0f172a' : '#f9fafb',
-    surfaceRaised: isDark ? '#1e293b' : '#ffffff',
-
-    text: isDark ? '#f9fafb' : '#111827',
-    textMuted: isDark ? '#94a3b8' : '#6b7280',
-    border: isDark ? '#334155' : '#e5e7eb',
-
-    radius: sharp ? '0px' : round ? '0.75rem' : '0.375rem',
-    radiusLg: sharp ? '0px' : round ? '1rem' : '0.5rem',
-    badgeRadius: '999px',
-
-    skeletonBg: isDark ? '#1e293b' : '#e5e7eb',
-    skeletonShimmer: isDark ? 'rgba(255,255,255,0.1)' : 'rgba(255,255,255,0.6)',
-
-    gradientStart: primary,
-    gradientEnd: '#fffbd5',
-    gradientBgEnd: isDark ? '#aba67a' : '#d7d4bc'
-  }
-}
-
-export function buildCss(t: ThemeTokens): string {
-  return `:root {
-  --ix-primary:          ${t.primary};
-  --ix-primary-hover:    ${t.primaryHover};
-  --ix-primary-contrast: ${t.primaryContrast};
-
-  --ix-danger:      ${t.danger};
-  --ix-danger-text: ${t.dangerText};
-
-  --ix-warning: ${t.warning};
-  --ix-success: ${t.success};
-  --ix-neutral: ${t.neutral};
-  --ix-ghost:   transparent;
-
-  --ix-primary-bg: ${t.primaryBg};
-  --ix-danger-bg:  ${t.dangerBg};
-  --ix-warning-bg: ${t.warningBg};
-  --ix-success-bg: ${t.successBg};
-  --ix-info-bg:    ${t.infoBg};
-
-  --ix-on-danger:  #ffffff;
-  --ix-on-warning: #000000;
-  --ix-on-success: #ffffff;
-  --ix-on-primary: ${t.resolvedContrast};
-
-  --ix-divider: ${t.divider};
-
-  --ix-surface:        ${t.surface};
-  --ix-surface-raised: ${t.surfaceRaised};
-
-  --ix-text:       ${t.text};
-  --ix-text-muted: ${t.textMuted};
-
-  --ix-border: ${t.border};
-  --ix-focus:  2px solid var(--ix-primary);
-
-  --ix-font: 'Segoe UI Variable', 'Segoe UI', 'Roboto', 'Noto Sans', system-ui, sans-serif;
-  --ix-font-mono: 'JetBrains Mono', 'SFMono-Regular', Consolas, monospace;
-
-  --ix-size-xs: 0.75rem;
-  --ix-size-sm: 0.875rem;
-  --ix-size-md: 1rem;
-  --ix-size-lg: 1.125rem;
-  --ix-size-xl: 1.25rem;
-
-  --ix-line-height: 1.5;
-
-  --ix-space-sm: 0.5rem;
-  --ix-space-md: 1rem;
-  --ix-space-lg: 1.5rem;
-
-  --ix-radius:       ${t.radius};
-  --ix-radius-lg:    ${t.radiusLg};
-  --ix-badge-radius: ${t.badgeRadius};
-
-  --ix-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
-
-  --ix-gradient:    linear-gradient(to right, ${t.gradientStart}, ${t.gradientEnd});
-  --ix-gradient-bg: linear-gradient(to right, ${t.gradientStart}, ${t.gradientBgEnd});
-
-  --ix-skeleton-bg:      ${t.skeletonBg};
-  --ix-skeleton-shimmer: ${t.skeletonShimmer};
-}`
-}