rushchatbot 1.6.7

package/package/src/server/index.ts

@@ -0,0 +1,210 @@
+import express from 'express'
+import cors from 'cors'
+import axios from 'axios'
+import fs from 'fs'
+import path from 'path'
+import { findMatch, MatchResult, Question } from './matcher'
+import { checkGuardrails, validateInput } from './guardrails'
+import type { ChatbotConfig } from '../shared/types'
+
+export interface RushChatbotServerOptions {
+  /** Absolute path to your chatbot.config.json */
+  configPath: string
+  /** Absolute path to your questions.json (English) */
+  questionsPath: string
+  /** Absolute path to your questions.tl.json (Tagalog, optional) */
+  questionsTagalogPath?: string
+  /** Port to listen on. Defaults to 3001 */
+  port?: number
+  /** CORS origin(s). Defaults to * */
+  corsOrigin?: string | string[]
+}
+
+type AnalyticsEntry = {
+  sessionId: string
+  questionId: string
+  timestamp: string
+  type: 'click' | 'match' | 'n8n' | 'error'
+}
+
+function parseN8nResponse(data: unknown): { paragraphs: string[] } | { answer: string } {
+  if (Array.isArray(data) && data.length > 0) {
+    const first = data[0]
+    if (Array.isArray(first?.paragraphs) && first.paragraphs.length > 0)
+      return { paragraphs: first.paragraphs.map(String) }
+    if (typeof first === 'string') return { answer: first }
+    if (first?.output) return { answer: String(first.output) }
+    if (first?.text) return { answer: String(first.text) }
+    if (first?.answer) return { answer: String(first.answer) }
+    if (first?.message) return { answer: String(first.message) }
+  }
+  if (typeof data === 'object' && data !== null) {
+    const obj = data as Record<string, unknown>
+    if (Array.isArray(obj.paragraphs)) return { paragraphs: obj.paragraphs.map(String) }
+    if (obj.output) return { answer: String(obj.output) }
+    if (obj.answer) return { answer: String(obj.answer) }
+    if (obj.text) return { answer: String(obj.text) }
+    if (obj.message) return { answer: String(obj.message) }
+  }
+  if (typeof data === 'string') return { answer: data }
+  return { answer: JSON.stringify(data) }
+}
+
+export function createServer(options: RushChatbotServerOptions) {
+  const {
+    configPath,
+    questionsPath,
+    questionsTagalogPath,
+    port = 3001,
+    corsOrigin = '*',
+  } = options
+
+  // Validate paths exist
+  if (!fs.existsSync(configPath)) throw new Error(`[RushChatbot] configPath not found: ${configPath}`)
+  if (!fs.existsSync(questionsPath)) throw new Error(`[RushChatbot] questionsPath not found: ${questionsPath}`)
+
+  const analyticsPath = path.join(path.dirname(configPath), 'analytics.json')
+
+  function getConfig(): ChatbotConfig {
+    return JSON.parse(fs.readFileSync(configPath, 'utf-8'))
+  }
+
+  function getQuestions(lang: 'en' | 'tl'): Question[] {
+    if (lang === 'tl') {
+      if (!questionsTagalogPath || !fs.existsSync(questionsTagalogPath)) return []
+      return JSON.parse(fs.readFileSync(questionsTagalogPath, 'utf-8'))
+    }
+    return JSON.parse(fs.readFileSync(questionsPath, 'utf-8'))
+  }
+
+  function getAnalytics(): AnalyticsEntry[] {
+    if (!fs.existsSync(analyticsPath)) return []
+    return JSON.parse(fs.readFileSync(analyticsPath, 'utf-8'))
+  }
+
+  function saveAnalytics(entry: AnalyticsEntry) {
+    try {
+      const analytics = getAnalytics()
+      analytics.push(entry)
+      fs.writeFileSync(analyticsPath, JSON.stringify(analytics, null, 2))
+    } catch (e) {
+      console.error('[RushChatbot analytics error]', e)
+    }
+  }
+
+  function getSid(req: express.Request): string {
+    return String(req.body?.sessionId ?? req.query?.sessionId ?? req.headers['x-session-id'] ?? 'unknown')
+  }
+
+  const app = express()
+  app.use(cors({ origin: corsOrigin }))
+  app.use(express.json())
+
+  const router = express.Router()
+
+  router.post('/click', (req, res) => {
+    const { questionId } = req.body
+    const sid = getSid(req)
+    if (!questionId || typeof questionId !== 'string')
+      return res.status(400).json({ error: 'questionId is required' })
+    saveAnalytics({ sessionId: sid, questionId, timestamp: new Date().toISOString(), type: 'click' })
+    res.json({ ok: true })
+  })
+
+  router.get('/query', async (req, res) => {
+    const cfg = getConfig()
+    const query = String(req.query.query ?? '').trim()
+    const sid = getSid(req)
+    if (!query) return res.status(400).json({ error: 'query param is required' })
+    try {
+      const { webhookUrl, timeoutMs = 55000 } = cfg.n8n
+      const { data } = await axios.post(
+        webhookUrl,
+        { query, sessionId: sid },
+        { timeout: timeoutMs, headers: { 'Content-Type': 'application/json', 'x-session-id': sid } }
+      )
+      return res.json({ ...parseN8nResponse(data), source: 'n8n' })
+    } catch (err: unknown) {
+      const message = err instanceof Error ? err.message : String(err)
+      console.error('[RushChatbot query GET error]', message)
+      return res.status(500).json({ error: message })
+    }
+  })
+
+  router.post('/query', async (req, res) => {
+    const sid = getSid(req)
+    const cfg = getConfig()
+    try {
+      const { query } = req.body
+      if (!query || typeof query !== 'string' || !query.trim())
+        return res.status(400).json({ error: 'query is required' })
+
+      const validation = validateInput(query.trim())
+      if (!validation.valid) {
+        saveAnalytics({ sessionId: sid, questionId: 'invalid_input', timestamp: new Date().toISOString(), type: 'error' })
+        return res.json({ answer: validation.response, source: 'validation' })
+      }
+
+      const guardrail = checkGuardrails(query.trim())
+      if (guardrail.flagged) {
+        saveAnalytics({ sessionId: sid, questionId: 'guardrail', timestamp: new Date().toISOString(), type: 'error' })
+        return res.json({ answer: guardrail.response, source: 'guardrail' })
+      }
+
+      let result: MatchResult | null = findMatch(query.trim(), getQuestions('en'), cfg.chat.matchThreshold ?? 0.4)
+      if (!result) result = findMatch(query.trim(), getQuestions('tl'), cfg.chat.matchThreshold ?? 0.4)
+
+      if (result) {
+        saveAnalytics({ sessionId: sid, questionId: result.question.id, timestamp: new Date().toISOString(), type: 'match' })
+        return res.json({
+          answer: result.question.answer,
+          source: 'config',
+          matchedQuestion: result.question.question,
+          matchedKeywords: result.matchedKeywords,
+          score: Math.round(result.score * 100),
+        })
+      }
+
+      const { webhookUrl, timeoutMs = 55000 } = cfg.n8n
+      if (!webhookUrl || webhookUrl.includes('your-n8n.com')) {
+        saveAnalytics({ sessionId: sid, questionId: 'n8n_not_configured', timestamp: new Date().toISOString(), type: 'error' })
+        return res.json({ answer: cfg.chat.fallbackMessage, source: 'error' })
+      }
+
+      saveAnalytics({ sessionId: sid, questionId: 'n8n', timestamp: new Date().toISOString(), type: 'n8n' })
+      const { data } = await axios.post(
+        webhookUrl,
+        { query: query.trim(), sessionId: sid },
+        { timeout: timeoutMs, headers: { 'Content-Type': 'application/json', 'x-session-id': sid } }
+      )
+      return res.json({ ...parseN8nResponse(data), source: 'n8n' })
+
+    } catch (err: unknown) {
+      const message = err instanceof Error ? err.message : String(err)
+      console.error('[RushChatbot query error]', message)
+      saveAnalytics({ sessionId: sid, questionId: 'error', timestamp: new Date().toISOString(), type: 'error' })
+      return res.status(500).json({ answer: cfg.chat.fallbackMessage, source: 'error' })
+    }
+  })
+
+  router.get('/questions', (_req, res) => {
+    const { chat } = getConfig()
+    res.json(getQuestions(chat.language === 'tl' ? 'tl' : 'en'))
+  })
+
+  router.get('/config', (_req, res) => {
+    const { branding, chat } = getConfig()
+    res.json({ branding, chat })
+  })
+
+  router.get('/analytics', (_req, res) => {
+    res.json(getAnalytics())
+  })
+
+  app.use('/api/chat', router)
+
+  return {
+    app,
+    listen: () => app.listen(port, () => console.log(`[RushChatbot] Server running on http://localhost:${port}`)),
+  }
+}

package/package/src/server/matcher.ts

@@ -0,0 +1,140 @@
+import Fuse from 'fuse.js'
+
+export interface Question {
+  id: string
+  question: string
+  answer: string
+  subquestions: Question[]
+}
+
+// Common stop words to ignore during keyword extraction
+const STOP_WORDS = new Set([
+  'a', 'an', 'the', 'is', 'are', 'was', 'were', 'be', 'been', 'being',
+  'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'could',
+  'should', 'may', 'might', 'shall', 'can', 'need', 'dare', 'ought',
+  'i', 'me', 'my', 'we', 'our', 'you', 'your', 'he', 'she', 'it', 'they',
+  'what', 'where', 'when', 'who', 'how', 'why', 'which',
+  'in', 'on', 'at', 'to', 'for', 'of', 'with', 'about', 'by', 'from',
+  'and', 'or', 'but', 'if', 'so', 'yet', 'nor',
+  'this', 'that', 'these', 'those', 'there', 'here',
+  'tell', 'give', 'show', 'know', 'want', 'like', 'get', 'find', 'look'
+])
+
+// Synonym map — only domain-specific terms, not generic words
+const SYNONYMS: Record<string, string[]> = {
+  website:     ['site', 'web', 'url', 'online', 'portal', 'link'],
+  email:       ['mail', 'e-mail'],
+  address:     ['location', 'situated'],
+  fee:         ['cost', 'price', 'charge', 'dues', 'rate', 'much'],
+  membership:  ['member', 'join', 'enroll', 'apply'],
+  contact:     ['reach', 'call', 'phone', 'inquire'],
+  benefit:     ['advantage', 'perk', 'privilege'],
+  program:     ['course', 'seminar', 'workshop', 'training'],
+  academy:     ['school', 'learning', 'education'],
+  award:       ['recognition', 'prize', 'honor', 'trophy'],
+  event:       ['conference', 'summit', 'forum', 'gathering'],
+  publication: ['journal', 'digest', 'magazine'],
+  mission:     ['goal', 'purpose', 'objective'],
+  founded:     ['established', 'started', 'created', 'history', 'origin'],
+  hours:       ['schedule', 'open', 'available'],
+  nominate:    ['nomination', 'recommend', 'propose'],
+  contribute:  ['write', 'author', 'publish'],
+}
+
+function extractKeywords(text: string): string[] {
+  return text
+    .toLowerCase()
+    .replace(/[^a-z0-9\s]/g, ' ')
+    .split(/\s+/)
+    .filter(w => w.length > 1 && !STOP_WORDS.has(w))
+}
+
+function expandWithSynonyms(keywords: string[]): string[] {
+  const expanded = new Set(keywords)
+  for (const [canonical, synonymList] of Object.entries(SYNONYMS)) {
+    for (const kw of keywords) {
+      if (synonymList.includes(kw) || kw === canonical) {
+        expanded.add(canonical)
+        synonymList.forEach(s => expanded.add(s))
+      }
+    }
+  }
+  return Array.from(expanded)
+}
+
+function keywordScore(rawKeywords: string[], expandedKeywords: string[], question: Question): { score: number; matched: string[] } {
+  const target = `${question.question} ${question.answer}`.toLowerCase()
+  const targetWords = new Set(target.replace(/[^a-z0-9\s]/g, ' ').split(/\s+/))
+
+  // Check raw keywords first for direct matches
+  const rawMatched = rawKeywords.filter(kw => targetWords.has(kw))
+
+  // Check expanded keywords but only count them if the canonical term hits
+  const expandedMatched = expandedKeywords.filter(kw => targetWords.has(kw))
+
+  // Deduplicate and use the larger matched set
+  const matched = Array.from(new Set([...rawMatched, ...expandedMatched]))
+
+  // Score based on raw keywords so expansion doesn't inflate the score
+  const score = rawMatched.length > 0
+    ? rawMatched.length / Math.max(rawKeywords.length, 1)
+    : expandedMatched.length > 0 ? 0.3 : 0  // small boost if only synonyms matched
+
+  return { score, matched }
+}
+
+function flattenQuestions(questions: Question[]): Question[] {
+  return questions.reduce<Question[]>((acc, q) => {
+    acc.push(q)
+    if (q.subquestions?.length) acc.push(...flattenQuestions(q.subquestions))
+    return acc
+  }, [])
+}
+
+export interface MatchResult {
+  question: Question
+  matchedKeywords: string[]
+  score: number
+}
+
+export function findMatch(
+  query: string,
+  questions: Question[],
+  threshold: number
+): MatchResult | null {
+  const flat = flattenQuestions(questions)
+
+  const rawKeywords = extractKeywords(query)
+  const expandedKeywords = expandWithSynonyms(rawKeywords)
+
+  const fuse = new Fuse(flat, {
+    keys: [
+      { name: 'question', weight: 0.7 },
+      { name: 'answer', weight: 0.3 }
+    ],
+    threshold: 0.2,
+    includeScore: true,
+    minMatchCharLength: 3,
+    ignoreLocation: true,
+  })
+
+  const fuseResults = fuse.search(query)
+
+  const candidates = flat.map(q => {
+    const fuseResult = fuseResults.find(r => r.item.id === q.id)
+    const fuseScore = fuseResult ? 1 - (fuseResult.score ?? 1) : 0
+    const { score: kwScore, matched } = keywordScore(rawKeywords, expandedKeywords, q)
+
+    // Require at least one keyword match AND a reasonable combined score
+    if (kwScore === 0) return { q, combined: 0, matchedKeywords: [] }
+
+    const combined = fuseScore * 0.4 + kwScore * 0.6
+    return { q, combined, matchedKeywords: matched }
+  })
+
+  const best = candidates
+    .filter(c => c.combined > 0.3)
+    .sort((a, b) => b.combined - a.combined)[0]
+
+  return best ? { question: best.q, matchedKeywords: best.matchedKeywords, score: best.combined } : null
+}

package/package/src/shared/types.ts

@@ -0,0 +1,58 @@
+export interface Question {
+  id: string
+  question: string
+  answer: string
+  subquestions: Question[]
+}
+
+export interface Theme {
+  primaryColor: string
+  backgroundColor: string
+  userBubbleColor: string
+  botBubbleColor: string
+  textColor: string
+  fontFamily: string
+}
+
+export interface ChatbotConfig {
+  branding: {
+    title: string
+    subtitle: string
+    avatarUrl?: string
+    theme: Theme
+  }
+  n8n: {
+    webhookUrl: string
+    timeoutMs?: number
+  }
+  chat: {
+    welcomeMessage: string
+    fallbackMessage: string
+    matchThreshold?: number
+    showPreQuestionsOnStart?: boolean
+    language?: 'en' | 'tl'
+  }
+}
+
+export interface Message {
+  id: string
+  role: 'user' | 'bot'
+  text: string
+  source?: 'config' | 'n8n' | 'error'
+  subquestions?: Question[]
+  isFollowUp?: boolean
+  isEndChat?: boolean
+}
+
+export interface WidgetSettings {
+  primaryColor?: string
+  bgColor?: string
+  borderRadius?: number
+  showShadow?: boolean
+  placeholder?: string
+  sendLabel?: string
+  hideInput?: boolean
+  hideEndChat?: boolean
+  autoOpen?: boolean
+  position?: 'bottom-right' | 'bottom-left'
+}

package/package/src/shims-vue.d.ts

@@ -0,0 +1,5 @@
+declare module '*.vue' {
+  import type { DefineComponent } from 'vue'
+  const component: DefineComponent<{}, {}, any>
+  export default component
+}