Implement hot-reloaded search rules config file for monk prefixes

webapp/tipitaka-api/app/services/search_rules.json

@@ -0,0 +1,31 @@
+{
+  "prefixes": [
+    "เรื่องพระมหา",
+    "ท่านพระมหา",
+    "เรื่องพระ",
+    "ท่านพระ",
+    "พระมหา",
+    "พระนาง",
+    "เรื่อง",
+    "ท่าน",
+    "พระ",
+    "มหา",
+    "นาง"
+  ],
+  "suffixes": [
+    "เถริยาปทาน",
+    "เถริยา",
+    "เถรวัตถุ",
+    "ภิกษุณี",
+    "อุบาสิกา",
+    "อุบาสก",
+    "เถระ",
+    "เถรี",
+    "ภิกขุ",
+    "ภิกษุ",
+    "วัตถุ",
+    "คาถา",
+    "อปทาน",
+    "เถร"
+  ]
+}

webapp/tipitaka-api/app/services/search_service.py

@@ -1,6 +1,8 @@
 import time
 import re
 import asyncio
+import json
+from pathlib import Path
 from typing import List, Optional
 from app.database.sqlite_db import SQLiteDB
 from app.schemas import SearchResponse, SearchResultItem
@@ -19,6 +21,47 @@ class SearchService:
         self.rag_service = rag_service
         self.qts = query_transform_service
 
+    def _load_search_rules(self):
+        """Load prefixes and suffixes from search_rules.json with hot-reloading based on file modified time."""
+        config_path = Path(__file__).resolve().parent / "search_rules.json"
+        
+        # Default fallback values if file loading fails or file doesn't exist
+        default_prefixes = [
+            "เรื่องพระมหา", "ท่านพระมหา", "เรื่องพระ", "ท่านพระ", 
+            "พระมหา", "พระนาง", "เรื่อง", "ท่าน", "พระ", "มหา", "นาง"
+        ]
+        default_suffixes = [
+            "เถริยาปทาน", "เถริยา", "เถรวัตถุ", "ภิกษุณี", "อุบาสิกา", 
+            "อุบาสก", "เถระ", "เถรี", "ภิกขุ", "ภิกษุ", "วัตถุ", "คาถา", "อปทาน", "เถร"
+        ]
+        
+        if not config_path.exists():
+            return default_prefixes, default_suffixes
+
+        try:
+            mtime = config_path.stat().st_mtime
+            # Check if cached values exist and file has not been modified
+            if hasattr(self, "_rules_cached_mtime") and self._rules_cached_mtime == mtime:
+                return self._cached_prefixes, self._cached_suffixes
+
+            with open(config_path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+            
+            prefixes = data.get("prefixes", default_prefixes)
+            suffixes = data.get("suffixes", default_suffixes)
+            
+            # Sort lists by length in descending order to avoid greedy prefix/suffix stripping issues
+            prefixes.sort(key=len, reverse=True)
+            suffixes.sort(key=len, reverse=True)
+            
+            self._cached_prefixes = prefixes
+            self._cached_suffixes = suffixes
+            self._rules_cached_mtime = mtime
+            
+            return prefixes, suffixes
+        except Exception:
+            return default_prefixes, default_suffixes
+
     # ── Autocomplete suggestions ────────────────────────────────────
 
 
@@ -262,8 +305,7 @@ class SearchService:
         tokens = [t.strip() for t in query_text.split() if t.strip()]
         variants = []
         
-        prefixes = ["เรื่องพระ", "เรื่อง", "ท่านพระ", "ท่าน", "พระนาง", "พระ", "นาง"]
-        suffixes = ["เถริยาปทาน", "เถริยา", "เถรวัตถุ", "ภิกษุณี", "อุบาสิกา", "อุบาสก", "เถระ", "เถรี", "ภิกขุ", "ภิกษุ", "วัตถุ", "คาถา", "อปทาน"]
+        prefixes, suffixes = self._load_search_rules()
         
         for t in tokens:
             t_clean = t.replace('"', '').replace('*', '').strip()
@@ -287,23 +329,19 @@ class SearchService:
                     break
                     
             if len(base) >= 3:
-                variants.extend([
-                    base, 
-                    f"พระ{base}", 
-                    f"เรื่องพระ{base}", 
-                    f"{base}เถรี", 
-                    f"{base}ภิกษุณี", 
-                    f"{base}เถระ",
-                    f"{base}เถริยา",
-                    f"{base}เถริยาปทาน",
-                    f"{base}วัตถุ",
-                    f"พระ{base}เถรี",
-                    f"พระ{base}เถระ"
-                ])
+                variants.append(base)
+                for pref in prefixes:
+                    variants.append(f"{pref}{base}")
+                for suff in suffixes:
+                    variants.append(f"{base}{suff}")
+                # Add some combination cases for common titles
+                variants.append(f"พระ{base}เถระ")
+                variants.append(f"พระ{base}เถรี")
+                variants.append(f"พระมหา{base}เถระ")
             else:
                 variants.append(t_clean)
                 
-        return list(set(variants))
+        return list(dict.fromkeys(v for v in variants if v.strip()))
 
     def _get_fts_results(self, query_text: str, limit: int = 50) -> List[dict]:
         """Run SQLite FTS5 search on query_text with prefix matching and prefix/suffix expansion."""
@@ -314,11 +352,7 @@ class SearchService:
         # Split into tokens by whitespace
         tokens = [t.strip() for t in thai_q.split() if t.strip()]
         
-        prefixes = ["เรื่องพระ", "เรื่อง", "ท่านพระ", "ท่าน", "พระนาง", "พระ", "นาง"]
-        prefixes.sort(key=len, reverse=True)
-        
-        suffixes = ["เถริยาปทาน", "เถริยา", "เถรวัตถุ", "ภิกษุณี", "อุบาสิกา", "อุบาสก", "เถระ", "เถรี", "ภิกขุ", "ภิกษุ", "วัตถุ", "คาถา", "อปทาน"]
-        suffixes.sort(key=len, reverse=True)
+        prefixes, suffixes = self._load_search_rules()
 
         processed_tokens = []
         for t in tokens:
@@ -349,7 +383,17 @@ class SearchService:
                     break
                     
             if len(base) >= 3:
-                variations = [base, f"พระ{base}", f"เรื่องพระ{base}"]
+                variations = [
+                    base,
+                    f"พระ{base}",
+                    f"มหา{base}",
+                    f"พระมหา{base}",
+                    f"เรื่องพระ{base}",
+                    f"เรื่องพระมหา{base}",
+                    f"ท่านพระ{base}",
+                    f"ท่านพระมหา{base}"
+                ]
+                variations = list(dict.fromkeys(v for v in variations if v.strip()))
                 clause = " OR ".join(f'"{v}"*' for v in variations)
                 processed_tokens.append(f"({clause})")
             else: