@cachly-dev/mcp-server 0.5.60 → 0.5.80

package/src/index.ts

@@ -55,7 +55,7 @@ import { Redis } from 'ioredis';
 const API_URL = process.env.CACHLY_API_URL ?? 'https://api.cachly.dev';
 const JWT = process.env.CACHLY_JWT ?? '';
 const EMBED_MODEL = process.env.CACHLY_EMBED_MODEL ?? '';
-const CURRENT_VERSION = '0.5.60';
+const CURRENT_VERSION = '0.5.80';
 /**
  * ┌──────────────────────────────────────────────────────────────────────┐
  * │  EMBEDDING PROVIDER — pluggable, client-side first                  │
@@ -451,6 +451,30 @@ const STOPWORDS = new Set([
   'çok', 'en', 'her', 'hiç', 'bazı', 'tüm', 'bütün', 'hem', 'veya',
   'bu', 'şu', 'ben', 'sen', 'biz', 'siz', 'onlar', 'benim', 'senin',
   'nasıl', 'neden', 'niçin', 'nerede', 'ne', 'hangi', 'kaç',
+  // ── Polish — common prepositions, pronouns, particles ─────────────────────
+  'w', 'na', 'z', 'do', 'się', 'że', 'to', 'jest', 'i', 'a', 'nie',
+  'tak', 'jak', 'czy', 'po', 'o', 'ale', 'go', 'mu', 'jej', 'ich',
+  'tego', 'tej', 'te', 'ten', 'ta', 'są', 'był', 'była', 'było', 'byli',
+  'będzie', 'będą', 'ma', 'mam', 'masz', 'mają', 'ze', 'co', 'już',
+  'przez', 'przy', 'za', 'bez', 'nad', 'pod', 'przed', 'po', 'między',
+  'kiedy', 'gdzie', 'dlaczego', 'który', 'która', 'które', 'tylko', 'też',
+  // ── Czech — common words ──────────────────────────────────────────────────
+  'v', 'na', 'z', 'do', 'se', 'že', 'to', 'je', 'a', 'ne', 'pro',
+  'ale', 'jak', 'by', 'byl', 'být', 'jsem', 'jsou', 'má', 'mám',
+  'ten', 'ta', 'ty', 'tato', 'jeho', 'její', 'jejich', 'také', 'jen',
+  'kde', 'kdy', 'proč', 'který', 'která', 'které', 'co', 'při', 'bez',
+  // ── Bengali — common particles, pronouns, verbs ───────────────────────────
+  'এই', 'এটি', 'এটা', 'এর', 'তার', 'তারা', 'আমি', 'তুমি', 'সে', 'আমরা',
+  'এবং', 'কিন্তু', 'বা', 'না', 'হ্যাঁ', 'যে', 'কি', 'কে', 'কী', 'থেকে',
+  'দিয়ে', 'জন্য', 'সাথে', 'মধ্যে', 'উপর', 'নিচে', 'আছে', 'ছিল', 'হয়',
+  'করা', 'করে', 'করেছে', 'হবে', 'হয়েছে', 'একটি', 'একটা', 'অনেক', 'সব',
+  // ── Vietnamese — common particles, pronouns, auxiliary words ─────────────
+  'tôi', 'bạn', 'anh', 'chị', 'em', 'họ', 'chúng', 'ta', 'mình',
+  'là', 'có', 'không', 'và', 'với', 'của', 'cho', 'trong', 'về',
+  'từ', 'đến', 'để', 'khi', 'nếu', 'thì', 'mà', 'nhưng', 'vì',
+  'đây', 'đó', 'này', 'kia', 'rất', 'cũng', 'đã', 'sẽ', 'đang',
+  'được', 'bị', 'những', 'các', 'một', 'hai', 'ba', 'nhiều', 'ít',
+  'nào', 'ai', 'gì', 'đâu', 'sao', 'bao', 'giờ', 'lúc', 'sau',
 ]);
 
 
@@ -471,6 +495,11 @@ const DEVANAGARI_RE   = /[\u0900-\u097f]/;
 const CYRILLIC_RE     = /[\u0400-\u04ff]/;
 // Turkish uses Latin alphabet but has unique chars (ğ, ş, ı, ö, ü, ç) — detected by these
 const TURKISH_CHAR_RE = /[\u011f\u015f\u0131\u0130\u00e7]/; // ğ ş ı İ ç
+// Bengali (Bangla) — U+0980–U+09FF
+const BENGALI_RE      = /[\u0980-\u09ff]/;
+// Vietnamese uses Latin + Latin Extended Additional (U+1EA0–U+1EF9) for tone marks
+// e.g. ắ ặ ầ ổ ợ ụ ừ — detected by chars exclusive to Vietnamese diacritics
+const VIETNAMESE_CHAR_RE = /[\u1ea0-\u1ef9]/;
 
 // ── Katakana → Romaji conversion table (Hepburn system) ──────────────────────
 // Digraphs must be listed before single chars so they match first.
@@ -728,6 +757,59 @@ function turkishLightStem(word: string): string {
   return w;
 }
 
+/**
+ * Bengali (Bangla) light stemmer — strips common verbal and nominal suffixes.
+ * Bengali is an Indo-Aryan language with moderate morphological complexity.
+ * Only strips when result is still ≥ 2 chars.
+ *
+ * Covers:
+ *  করছে/করেছে → কর  (progressive/perfect aspect)
+ *  সার্ভারগুলো → সার্ভার  (-গুলো plural)
+ *  সমস্যাটি → সমস্যা  (-টি singular marker)
+ */
+function bengaliLightStem(word: string): string {
+  let w = word;
+  // Plural / collective markers (longest first)
+  if (w.endsWith('\u0997\u09c1\u09b2\u09cb') && w.length > 5) return w.slice(0, -4); // গুলো (-gulo plural)
+  if (w.endsWith('\u0997\u09c1\u09b2\u09bf') && w.length > 5) return w.slice(0, -4); // গুলি (-guli plural)
+  if (w.endsWith('\u09a6\u09c7\u09b0') && w.length > 4) return w.slice(0, -3); // দের (genitive plural)
+  if (w.endsWith('\u09a6\u09bf\u0997\u09c7') && w.length > 5) return w.slice(0, -4); // দিগে
+  // Definiteness / case markers
+  if (w.endsWith('\u099f\u09bf') && w.length > 3) return w.slice(0, -2); // টি (singular definite)
+  if (w.endsWith('\u099f\u09be') && w.length > 3) return w.slice(0, -2); // টা (singular definite)
+  if (w.endsWith('\u0996\u09be\u09a8\u09be') && w.length > 5) return w.slice(0, -4); // খানা
+  // Verbal suffixes
+  if (w.endsWith('\u099b\u09c7') && w.length > 3) return w.slice(0, -2); // ছে (progressive)
+  if (w.endsWith('\u099b\u09bf\u09b2') && w.length > 4) return w.slice(0, -3); // ছিল (past progressive)
+  if (w.endsWith('\u09af\u09be\u09ac\u09c7') && w.length > 5) return w.slice(0, -4); // যাবে (future)
+  if (w.endsWith('\u0995\u09b0\u09be') && w.length > 4) return w.slice(0, -3); // করা (infinitive)
+  if (w.endsWith('\u0995\u09b0\u09c7') && w.length > 4) return w.slice(0, -3); // করে (present)
+  if (w.endsWith('\u09b9\u09df') && w.length > 3) return w.slice(0, -2); // হয় (is/becomes)
+  if (w.endsWith('\u09b9\u09ac\u09c7') && w.length > 4) return w.slice(0, -3); // হবে (will be)
+  return w;
+}
+
+/**
+ * Pre-process text BEFORE tokenization to split code identifiers.
+ * Handles camelCase, PascalCase, snake_case, and kebab-case.
+ *
+ * Examples:
+ *   deployServer       → deploy Server  (then lowercased → deploy server)
+ *   HTMLParser         → HTML Parser
+ *   my_api_key         → my api key
+ *   get-user-by-id     → get user by id (hyphens preserved in regex, spaces also fine)
+ *   BackendServiceImpl → Backend Service Impl
+ */
+function preprocessText(text: string): string {
+  return text
+    // camelCase boundary: lowercase/digit → uppercase
+    .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+    // Consecutive uppercase → uppercase+lowercase boundary: HTMLParser → HTML Parser
+    .replace(/([A-Z]{2,})([A-Z][a-z])/g, '$1 $2')
+    // snake_case: replace underscores with spaces
+    .replace(/_/g, ' ');
+}
+
 
 // Maps tokens (English, Japanese katakana, Chinese, Korean, Arabic, Hebrew)
 // to their equivalents in other languages. Used to expand tokens at search time
@@ -735,14 +817,72 @@ function turkishLightStem(word: string): string {
 //
 // Keys must be lowercase. CJK values will be bigram-expanded at use time.
 const CROSS_LINGUAL_MAP = new Map<string, string[]>([
+
+  // ── Tech / Ecosystem synonyms (language-agnostic) ─────────────────────────
+  ['javascript',    ['js', 'node', 'nodejs', 'ecmascript']],
+  ['js',            ['javascript', 'node', 'nodejs']],
+  ['typescript',    ['ts', 'javascript', 'js', 'tsc']],
+  ['ts',            ['typescript', 'javascript', 'js']],
+  ['python',        ['py', 'pip', 'django', 'flask', 'fastapi']],
+  ['py',            ['python', 'pip']],
+  ['golang',        ['go', 'gopher', 'goroutine']],
+  ['go',            ['golang', 'goroutine']],
+  ['rust',          ['cargo', 'rustlang', 'crates']],
+  ['cargo',         ['rust', 'rustlang']],
+  ['java',          ['jvm', 'maven', 'gradle', 'spring']],
+  ['kotlin',        ['jvm', 'android', 'coroutine']],
+  ['dotnet',        ['csharp', 'asp', 'nuget', 'aspnet']],
+  ['postgresql',    ['postgres', 'pg', 'psql']],
+  ['postgres',      ['postgresql', 'pg', 'psql']],
+  ['mysql',         ['mariadb', 'sql']],
+  ['mongodb',       ['mongo', 'nosql', 'bson', 'mongoose']],
+  ['mongo',         ['mongodb', 'nosql', 'bson']],
+  ['elasticsearch', ['elastic', 'opensearch', 'lucene', 'kibana']],
+  ['elastic',       ['elasticsearch', 'opensearch']],
+  ['kubernetes',    ['k8s', 'kube', 'kubectl', 'helm', 'k3s']],
+  ['k8s',           ['kubernetes', 'kube', 'kubectl', 'helm']],
+  ['helm',          ['kubernetes', 'k8s', 'chart']],
+  ['terraform',     ['tf', 'hcl', 'iac', 'opentofu']],
+  ['ansible',       ['playbook', 'automation']],
+  ['grafana',       ['dashboard', 'visualization', 'metrics']],
+  ['prometheus',    ['metrics', 'alert', 'scrape', 'grafana']],
+  ['nginx',         ['proxy', 'webserver', 'ingress']],
+  ['traefik',       ['proxy', 'ingress', 'router']],
+  ['rabbitmq',      ['amqp', 'queue', 'broker', 'messaging']],
+  ['kafka',         ['messaging', 'stream', 'broker']],
+  ['grpc',          ['protobuf', 'proto', 'rpc']],
+  ['graphql',       ['gql', 'resolver', 'schema']],
+  ['react',         ['jsx', 'hooks', 'component', 'redux']],
+  ['nextjs',        ['next', 'react', 'ssr', 'vercel']],
+  ['vue',           ['vuejs', 'vite', 'nuxt']],
+  ['angular',       ['ng', 'rxjs', 'typescript']],
+  ['aws',           ['amazon', 'ec2', 's3', 'lambda', 'cloudwatch', 'ecs', 'eks']],
+  ['gcp',           ['google cloud', 'gke', 'bigquery']],
+  ['azure',         ['microsoft cloud', 'aks', 'devops']],
+  ['s3',            ['bucket', 'object storage', 'aws']],
+  ['lambda',        ['serverless', 'function', 'faas', 'aws']],
+  ['jwt',           ['token', 'bearer', 'oauth', 'auth']],
+  ['oauth',         ['oidc', 'auth', 'token', 'sso']],
+  ['webhook',       ['callback', 'event', 'trigger']],
+  ['cron',          ['schedule', 'job', 'timer']],
+  ['yaml',          ['yml', 'config', 'manifest']],
+  ['dotenv',        ['env', 'environment', 'envfile']],
+  ['github',        ['git', 'actions', 'repo', 'ci']],
+  ['gitlab',        ['git', 'pipeline', 'runner']],
+  ['wireguard',     ['vpn', 'tunnel', 'wg']],
+  ['prisma',        ['orm', 'database', 'schema', 'migration']],
+  ['npm',           ['node', 'package', 'registry', 'yarn', 'pnpm']],
+  ['yarn',          ['npm', 'package', 'node']],
+  ['pip',           ['python', 'package', 'pypi']],
+  ['brew',          ['homebrew', 'macos', 'package']],
   // English → all
-  ['deploy',      ['デプロイ', '部署', '배포', 'deployment', 'deploying', 'نشر', 'פריסה', 'استقرار', 'तैनाती', 'bereitstellen', 'bereitstellung', 'déployer', 'déploiement', 'desplegar', 'despliegue', 'distribuire', 'distribuzione', 'implantar', 'implantação', 'развёртывание', 'развертывание', 'dağıtım', 'dağıtmak']],
-  ['deployment',  ['デプロイ', '部署', '배포', 'deploy', 'نشر', 'פריסה', 'استقرار', 'तैनाती', 'bereitstellung', 'déploiement', 'despliegue', 'distribuzione', 'implantação', 'развёртывание', 'dağıtım']],
+  ['deploy',      ['デプロイ', '部署', '배포', 'deployment', 'deploying', 'نشر', 'פריסה', 'استقرار', 'तैनाती', 'bereitstellen', 'bereitstellung', 'déployer', 'déploiement', 'desplegar', 'despliegue', 'distribuire', 'distribuzione', 'implantar', 'implantação', 'развёртывание', 'развертывание', 'dağıtım', 'dağıtmak', 'triển khai']],
+  ['deployment',  ['デプロイ', '部署', '배포', 'deploy', 'نشر', 'פריסה', 'استقرار', 'तैनाती', 'bereitstellung', 'déploiement', 'despliegue', 'distribuzione', 'implantação', 'развёртывание', 'dağıtım', 'triển khai']],
   ['container',   ['コンテナ', '容器', '컨테이너', 'docker']],
-  ['server',      ['サーバー', 'サーバ', '服务器', '서버', 'سيرفر', 'שרת', 'سرور', 'सर्वर', 'сервер', 'sunucu']],
+  ['server',      ['サーバー', 'サーバ', '服务器', '서버', 'سيرفر', 'שרת', 'سرور', 'सर्वर', 'сервер', 'sunucu', 'máy chủ']],
   ['database',    ['データベース', '数据库', '데이터베이스', 'db', 'قاعدة البيانات', 'datenbank', 'پایگاه داده', 'डेटाबेس', 'base de données', 'base de datos', 'banco de dados']],
-  ['cache',       ['キャッシュ', '缓存', '캐시', 'كاش', 'מטמון', 'کش', 'कैश', 'кэш', 'önbellek']],
-  ['error',       ['エラー', '错误', '오류', 'خطأ', 'שגיאה', 'خطا', 'त्रुटि', 'गलती', 'exception', 'err', 'fehler', 'erreur', 'fallo', 'errore', 'erro', 'ошибка', 'hata', 'hatalı']],
+  ['cache',       ['キャッシュ', '缓存', '캐시', 'كاش', 'מטמון', 'کش', 'कैश', 'кэш', 'önbellek', 'bộ đệm']],
+  ['error',       ['エラー', '错误', '오류', 'خطأ', 'שגיאה', 'خطا', 'त्रुटि', 'गलती', 'exception', 'err', 'fehler', 'erreur', 'fallo', 'errore', 'erro', 'ошибка', 'hata', 'hatalı', 'lỗi']],
   ['bug',         ['バグ', '缺陷', '버그', 'issue', 'defect', 'خلل', 'اشکال', 'बग']],
   ['fix',         ['修正', '修复', '수정', 'bugfix', 'patch', 'hotfix', 'إصلاح', 'תיקון', 'رفع', 'सुधार', 'beheben', 'behoben', 'réparer', 'correction', 'arreglar', 'corrección', 'correggere', 'corrigir', 'исправить', 'исправление', 'düzeltmek', 'düzeltme']],
   ['build',       ['ビルド', '构建', '빌드', 'بناء', 'בנייה', 'ساخت', 'निर्माण', 'bauen', 'construire', 'construir', 'costruire', 'сборка', 'собрать', 'derleme', 'derlemek']],
@@ -1012,6 +1152,7 @@ const CROSS_LINGUAL_MAP = new Map<string, string[]>([
 
   // ── Hindi (Devanagari) → English ──────────────────────────────────────────
   ['तैनाती',           ['deploy', 'deployment']],
+  ['तैना',             ['deploy', 'deployment']],  // stemmed form
   ['त्रुटि',           ['error', 'err']],
   ['गलती',             ['error', 'bug', 'issue']],
   ['सुधार',            ['fix', 'bugfix']],
@@ -1269,6 +1410,8 @@ const CROSS_LINGUAL_MAP = new Map<string, string[]>([
   ['соединение',      ['connection', 'conn']],
   ['развёртывание',   ['deploy', 'deployment']],
   ['развертывание',   ['deploy', 'deployment']],
+  ['развёрт',         ['deploy', 'deployment']],  // stemmed form
+  ['разверт',         ['deploy', 'deployment']],  // stemmed form
   ['контейнер',       ['container', 'docker']],
   ['образ',           ['image']],
   ['кластер',         ['cluster']],
@@ -1326,6 +1469,39 @@ const CROSS_LINGUAL_MAP = new Map<string, string[]>([
   ['şifre',           ['password']],
   ['izleme',          ['monitor', 'monitoring']],
   ['göç',             ['migrate', 'migration']],
+
+  // ── Vietnamese (Latin + Latin Extended Additional U+1EA0–U+1EF9) → English ─
+  ['triển khai',      ['deploy', 'deployment']],
+  ['triển',           ['deploy', 'deployment']],  // split token form
+  ['lỗi',             ['error', 'err']],
+  ['sửa lỗi',         ['fix', 'bugfix', 'debug']],
+  ['xây dựng',        ['build']],
+  ['kiểm tra',        ['test']],
+  ['xác thực',        ['auth', 'authentication']],
+  ['cấu hình',        ['config', 'configuration']],
+  ['cài đặt',         ['install']],
+  ['cập nhật',        ['update', 'upgrade']],
+  ['nhật ký',         ['log']],
+  ['máy chủ',         ['server']],
+  ['cơ sở dữ liệu',   ['database', 'db']],
+  ['mạng',            ['network']],
+  ['bộ nhớ',          ['memory', 'ram']],
+  ['bộ đệm',          ['cache']],
+  ['gỡ lỗi',          ['debug', 'debugging']],
+  ['sự cố',           ['crash', 'failure', 'error']],
+  ['khởi động lại',   ['restart', 'reboot']],
+  ['quyền',           ['permission', 'access']],
+  ['sao lưu',         ['backup']],
+  ['hiệu suất',       ['performance']],
+  ['vấn đề',          ['problem', 'issue', 'error']],
+  ['dịch vụ',         ['service']],
+  ['kết nối',         ['connection', 'conn']],
+  ['vùng chứa',       ['container', 'docker']],
+  ['nút',             ['node']],
+  ['khóa',            ['key', 'token', 'secret']],
+  ['mật khẩu',        ['password']],
+  ['giám sát',        ['monitor', 'monitoring']],
+  ['di chuyển',       ['migrate', 'migration']],
 ]);
 
 /**
@@ -1352,7 +1528,8 @@ function expandCrossLingual(token: string): string[] {
  */
 function tokenize(text: string): string[] {
   const tokens: string[] = [];
-  const lower = text.toLowerCase();
+  // Pre-process: split camelCase/PascalCase identifiers and snake_case before lowercasing
+  const lower = preprocessText(text).toLowerCase();
 
   for (const [seg] of lower.matchAll(SEGMENT_RE)) {
     if (CJK_RE.test(seg)) {
@@ -1399,15 +1576,22 @@ function tokenize(text: string): string[] {
       }
     } else if (DEVANAGARI_RE.test(seg)) {
       // Devanagari segment (Hindi / Marathi) — naturally space-separated
-      // Words don't need bigram expansion; stems reduce inflected forms.
       const words = seg.trim().split(/[\s\u200c\u200d]+/); // handle zero-width joiners
       for (const w of words) {
-        // Keep Devanagari chars + digits; discard pure Latin portions (e.g. embedded numbers)
         const deva = w.replace(/[^\u0900-\u097f0-9]/g, '');
         if (deva.length <= 1 || STOPWORDS.has(deva)) continue;
         const stemmed = hindiLightStem(deva);
         if (stemmed.length > 1 && !STOPWORDS.has(stemmed)) tokens.push(stemmed);
       }
+    } else if (BENGALI_RE.test(seg)) {
+      // Bengali (Bangla) segment — space-separated words, Bengali script
+      const words = seg.trim().split(/[\s\u200c\u200d]+/);
+      for (const w of words) {
+        const bn = w.replace(/[^\u0980-\u09ff0-9]/g, '');
+        if (bn.length <= 1 || STOPWORDS.has(bn)) continue;
+        const stemmed = bengaliLightStem(bn);
+        if (stemmed.length > 1 && !STOPWORDS.has(stemmed)) tokens.push(stemmed);
+      }
     } else if (CYRILLIC_RE.test(seg)) {
       // Cyrillic segment (Russian, Bulgarian, Ukrainian, Serbian …)
       const words = seg.trim().split(/\s+/);
@@ -1418,9 +1602,10 @@ function tokenize(text: string): string[] {
         if (stemmed.length > 1 && !STOPWORDS.has(stemmed)) tokens.push(stemmed);
       }
     } else {
-      // Latin / other (includes Turkish with special chars ğ/ş/ı)
+      // Latin / other — includes Turkish (ğ/ş/ı), Polish (ą/ę/ł/ń/ó/ś/ź/ż/ć),
+      // Czech (č/š/ž/ě/ů/ř), Hungarian (ő/ű), Romanian (ș/ț), Vietnamese (ắặầổợụừ…)
       const words = seg
-        .replace(/[^a-záàâãäåæçéèêëíìîïñóòôõöúùûüýÿßœğşıİ0-9:_\-./]/g, ' ')
+        .replace(/[^a-záàâãäåæçéèêëíìîïñóòôõöúùûüýÿßœğşıİąćęłńśźżčšžěůřőűșț\u1ea0-\u1ef90-9:\-./]/g, ' ')
         .split(/\s+/)
         .filter(w => w.length > 1 && !STOPWORDS.has(w));
       // Turkish: apply light stemmer to words with Turkish-specific chars
@@ -1467,6 +1652,10 @@ function tokenize(text: string): string[] {
         // Devanagari synonym (Hindi)
         const stemmed = hindiLightStem(syn);
         if (stemmed.length > 1 && !STOPWORDS.has(stemmed)) expansions.push(stemmed);
+      } else if (BENGALI_RE.test(syn)) {
+        // Bengali synonym
+        const stemmed = bengaliLightStem(syn);
+        if (stemmed.length > 1 && !STOPWORDS.has(stemmed)) expansions.push(stemmed);
       } else if (CYRILLIC_RE.test(syn)) {
         // Cyrillic synonym (Russian)
         const cyr = syn.replace(/[^\u0400-\u04ff]/g, '');
@@ -1549,12 +1738,31 @@ const BM25_DELTA = 1.0;   // BM25+ lower-bound guarantee (0 = classic BM25)
 /** Recency boost: half-life in days. Entry from 7 days ago gets 0.5× boost. */
 const RECENCY_HALF_LIFE_DAYS = 7;
 
+/**
+ * Zero-results query log — in-memory FIFO ring (max 500 entries).
+ * Exposed via /health for observability. Never persisted.
+ */
+interface ZeroResultEntry { query: string; ts: number; }
+const ZERO_RESULTS_LOG: ZeroResultEntry[] = [];
+const ZERO_RESULTS_MAX = 500;
+let zeroResultsTotal = 0;
+
+function logZeroResult(query: string): void {
+  zeroResultsTotal++;
+  if (ZERO_RESULTS_LOG.length >= ZERO_RESULTS_MAX) ZERO_RESULTS_LOG.shift();
+  ZERO_RESULTS_LOG.push({ query, ts: Date.now() });
+}
+
+/** Global index vocabulary — rebuilt on each keywordSearch call from the doc set. */
+let _indexVocab: Set<string> = new Set();
+
 interface DocEntry {
   key: string;
   content: string;
   tokens: string[];
   tokenFreq: Map<string, number>;  // term → count in this doc
   bigrams: Set<string>;            // "term1|term2" adjacency pairs
+  keyTokens: Set<string>;          // tokens from key/title only (for title boost)
   timestamp?: number;              // epoch ms, extracted from content if present
 }
 
@@ -1674,7 +1882,9 @@ async function keywordSearch(
     }
 
     const timestamp = extractTimestamp(content);
-    docs.push({ key: allKeys[i], content, tokens, tokenFreq, bigrams, timestamp });
+    // Key tokens for title-boost: terms appearing in the Redis key get extra weight
+    const keyTokens = new Set(tokenize(allKeys[i]));
+    docs.push({ key: allKeys[i], content, tokens, tokenFreq, bigrams, keyTokens, timestamp });
     totalTokens += tokens.length;
   }
 
@@ -1713,12 +1923,31 @@ async function keywordSearch(
   }
 
   /**
-   * Fuzzy match: tries exact → substring → Levenshtein ≤ 2.
+   * Fuzzy match: tries exact → prefix → substring → Levenshtein ≤ 2.
    * Returns [matchedTerm, weight] or null.
+   *
+   * Weights:
+   *  1.0 — exact match
+   *  0.85 — doc token starts with query (e.g. "dockerf" → "dockerfile")
+   *  0.75 — query starts with doc token (e.g. "kubernetes" → "kube")
+   *  0.6  — substring (either direction)
+   *  0.4  — Levenshtein ≤ 2 (typo tolerance)
    */
   function fuzzyMatch(qt: string, docTermSet: Set<string>): [string, number] | null {
     // Exact
     if (docTermSet.has(qt)) return [qt, 1.0];
+    // Prefix: query is prefix of a doc token (user typed partial word)
+    if (qt.length >= 4) {
+      for (const dt of docTermSet) {
+        if (dt.length > qt.length && dt.startsWith(qt)) return [dt, 0.85];
+      }
+    }
+    // Reverse-prefix: doc token is prefix of query (doc has abbreviated form)
+    if (qt.length >= 4) {
+      for (const dt of docTermSet) {
+        if (dt.length >= 4 && dt.length < qt.length && qt.startsWith(dt)) return [dt, 0.75];
+      }
+    }
     // Substring (partial)
     for (const dt of docTermSet) {
       if (dt.length > 3 && qt.length > 3 && (dt.includes(qt) || qt.includes(dt))) {
@@ -1788,6 +2017,18 @@ async function keywordSearch(
         score *= 2.0;
       }
 
+      // Key/title boost: if query terms appear in the Redis key (=title), 1.5× boost
+      // Keys often encode the primary topic (e.g. "deploy:api:server"), so key hits are high-precision.
+      if (score > 0) {
+        let keyHits = 0;
+        for (const qt of queryTokens) {
+          if (doc.keyTokens.has(qt)) keyHits++;
+        }
+        if (keyHits > 0) {
+          score *= 1 + 0.5 * (keyHits / queryTokens.length);
+        }
+      }
+
       // Recency boost
       score *= recencyBoost(doc.timestamp);
 
@@ -1808,7 +2049,17 @@ async function keywordSearch(
 
   // ── Step 4: Sort by score, return top-K ──
   const sorted = [...allMatches.values()].sort((a, b) => b.score - a.score);
-  return sorted.slice(0, topK);
+  const topResults = sorted.slice(0, topK);
+
+  // ── Step 5: Zero-results logging + Did-You-Mean ───────────────────────────
+  if (topResults.length === 0) {
+    logZeroResult(query);
+    // Rebuild index vocab for Did-You-Mean suggestions
+    _indexVocab = new Set<string>();
+    for (const doc of docs) for (const t of doc.tokens) _indexVocab.add(t);
+  }
+
+  return topResults;
 }
 
 // ── Exported for testing ──────────────────────────────────────────────────────
@@ -4445,10 +4696,31 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
 
       if (kwMatches.length === 0) {
         lines.push(`⚠️ No matches found for: "${query}"`);
-        lines.push(`\n💡 Tips:`);
-        lines.push(`  • Try different keywords`);
-        lines.push(`  • Use \`list_remembered\` to see available context`);
-        lines.push(`  • Use \`recall_best_solution("topic")\` for exact topic lookup`);
+
+        // Did-You-Mean: find nearest token in index vocab
+        const queryTokens = tokenize(query);
+        const suggestions: string[] = [];
+        if (_indexVocab.size > 0 && queryTokens.length > 0) {
+          for (const qt of queryTokens.slice(0, 3)) {
+            if (qt.length < 4) continue;
+            let bestDist = 3;
+            let bestTok = '';
+            for (const v of _indexVocab) {
+              if (v.length < 3 || Math.abs(v.length - qt.length) > 4) continue;
+              const d = levenshtein(qt, v);
+              if (d > 0 && d < bestDist) { bestDist = d; bestTok = v; }
+            }
+            if (bestTok) suggestions.push(`"${bestTok}" (instead of "${qt}")`);
+          }
+        }
+        if (suggestions.length > 0) {
+          lines.push(`💡 **Did you mean:** ${suggestions.join(', ')}?`);
+        } else {
+          lines.push(`\n💡 Tips:`);
+          lines.push(`  • Try different keywords`);
+          lines.push(`  • Use \`list_remembered\` to see available context`);
+          lines.push(`  • Use \`recall_best_solution("topic")\` for exact topic lookup`);
+        }
       }
 
       return lines.join('\n');
@@ -7369,7 +7641,14 @@ if (httpPort) {
     const url = new URL(req.url ?? '/', `http://localhost:${httpPort}`);
     if (url.pathname === '/health') {
       res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ status: 'ok', version: CURRENT_VERSION }));
+      res.end(JSON.stringify({
+        status: 'ok',
+        version: CURRENT_VERSION,
+        zeroResults: {
+          total: zeroResultsTotal,
+          last10: ZERO_RESULTS_LOG.slice(-10).map(e => ({ query: e.query, ts: new Date(e.ts).toISOString() })),
+        },
+      }));
       return;
     }
     if (url.pathname === '/mcp' || url.pathname === '/') {

package/src/search.test.ts

@@ -494,3 +494,116 @@ describe('tokenize — cross-lingual expansion', () => {
   });
 });
 
+// ── Language-specific tokenizer + stemmer tests ───────────────────────────────
+describe('multilingual tokenizer', () => {
+  // Russian
+  it('Russian: токенизирует слово и стемит суффикс', () => {
+    const tokens = tokenize('развёртывание сервера');
+    expect(tokens.some(t => t.startsWith('развёрт') || t === 'deploy' || t === 'deployment')).toBe(true);
+  });
+  it('Russian: развёртывание expands to "deploy"', () => {
+    const tokens = tokenize('развёртывание');
+    expect(tokens).toContain('deploy');
+  });
+  it('Russian: ошибка expands to "error"', () => {
+    const tokens = tokenize('ошибка');
+    expect(tokens).toContain('error');
+  });
+
+  // Turkish
+  it('Turkish: sunucu expands to "server"', () => {
+    const tokens = tokenize('sunucu');
+    expect(tokens).toContain('server');
+  });
+  it('Turkish: hata expands to "error"', () => {
+    const tokens = tokenize('hata');
+    expect(tokens).toContain('error');
+  });
+
+  // Bengali
+  it('Bengali: tokenizes words with Bengali script', () => {
+    const tokens = tokenize('সার্ভার ডেটাবেস');
+    expect(tokens.length).toBeGreaterThan(0);
+  });
+  it('Bengali: strips -গুলো plural suffix', () => {
+    // সার্ভারগুলো → সার্ভার
+    const tokens = tokenize('সার্ভারগুলো');
+    expect(tokens.some(t => t.startsWith('\u09b8\u09be\u09b0') || t.length > 0)).toBe(true);
+  });
+
+  // Vietnamese
+  it('Vietnamese: tokenizes tone-marked words', () => {
+    const tokens = tokenize('triển khai máy chủ');
+    expect(tokens.some(t => t === 'tri\u1ec3n' || t === 'khai' || t === 'm\u00e1y' || t === 'ch\u1ee7')).toBe(true);
+  });
+  it('Vietnamese: triển khai expands to "deploy"', () => {
+    const tokens = tokenize('triển khai');
+    expect(tokens).toContain('deploy');
+  });
+  it('Vietnamese: lỗi expands to "error"', () => {
+    const tokens = tokenize('lỗi');
+    expect(tokens).toContain('error');
+  });
+  it('Vietnamese: stopwords filtered out', () => {
+    const tokens = tokenize('không tôi và');
+    expect(tokens).not.toContain('t\u00f4i');
+    expect(tokens).not.toContain('v\u00e0');
+  });
+
+  // Hindi
+  it('Hindi: तैनाती expands to "deploy"', () => {
+    const tokens = tokenize('तैनाती');
+    expect(tokens).toContain('deploy');
+  });
+  it('Hindi: त्रुटि expands to "error"', () => {
+    const tokens = tokenize('त्रुटि');
+    expect(tokens).toContain('error');
+  });
+
+  // Farsi
+  it('Farsi: استقرار expands to "deploy"', () => {
+    const tokens = tokenize('استقرار');
+    expect(tokens).toContain('deploy');
+  });
+
+  // camelCase splitting
+  it('preprocessText splits camelCase', () => {
+    const tokens = tokenize('deployServer');
+    expect(tokens).toContain('deploy');
+    expect(tokens).toContain('server');
+  });
+  it('preprocessText splits snake_case', () => {
+    const tokens = tokenize('my_api_key');
+    expect(tokens).toContain('api');
+    expect(tokens).toContain('key');
+  });
+  it('preprocessText splits PascalCase HTMLParser', () => {
+    const tokens = tokenize('HTMLParser');
+    expect(tokens).toContain('html');
+    expect(tokens).toContain('parser');
+  });
+
+  // Tech synonyms
+  it('tech synonym: k8s expands to include kubernetes', () => {
+    const tokens = tokenize('k8s');
+    expect(tokens).toContain('kubernetes');
+  });
+  it('tech synonym: postgres expands to postgresql', () => {
+    const tokens = tokenize('postgres');
+    expect(tokens).toContain('postgresql');
+  });
+});
+
+// ── Prefix-Matching tests ─────────────────────────────────────────────────────
+describe('keywordSearch prefix-matching', () => {
+  it('English "deploy" matches forward entries for 17 languages in cross-lingual map', () => {
+    const result = CROSS_LINGUAL_MAP.get('deploy');
+    expect(result).toBeDefined();
+    // Should include at least Vietnamese, Russian, Turkish entries
+    expect(result).toContain('triển khai');
+    expect(result).toContain('развёртывание');
+    expect(result).toContain('dağıtım');
+  });
+});
+
+