feat(store): replace PostgreSQL FTS with BM25 in HybridStore

Replace ts_rank_cd (PostgreSQL Full-Text Search) with BM25 algorithm
for better keyword search ranking in hybrid search.

Changes:
- Add bm25Language parameter (configurable via YAML)
- Replace FTS CTEs with bm25topk() function calls
- Add DISTINCT ON fixes to prevent duplicate results
- Add fuzzy matching with word_similarity (pg_trgm)
- Add score normalization (0-100 range)
- Add searchable attributes with field-specific boosting
- Bundle configuration in options.php and AiBundle.php

Tests:
- Update 6 existing tests for BM25 compatibility
- Add 3 new tests for fuzzy matching and searchable attributes
- All 19 tests passing (132 assertions)

Breaking changes:
- Requires plpgsql_bm25 extension instead of native FTS
- BM25 uses short language codes ('en', 'fr') vs FTS full names

Author: ahmed-bhs

src/ai-bundle/config/options.php

@@ -765,6 +765,10 @@
                                     ->info('PostgreSQL text search configuration (e.g., "simple", "english", "french"). Default: "simple" (multilingual)')
                                     ->defaultValue('simple')
                                 ->end()
+                                ->stringNode('bm25_language')
+                                    ->info('BM25 language code for stemming (e.g., "en", "fr", "es", "de", "it", "pt", "nl", "ru", "ar", "zh"). Default: "en"')
+                                    ->defaultValue('en')
+                                ->end()
                                 ->integerNode('rrf_k')
                                     ->info('RRF (Reciprocal Rank Fusion) constant. Higher = more equal weighting. Default: 60 (Supabase)')
                                     ->defaultValue(60)
@@ -774,6 +778,56 @@
                                     ->info('Default maximum distance threshold for filtering results (optional)')
                                     ->defaultNull()
                                 ->end()
+                                ->floatNode('default_min_score')
+                                    ->info('Default minimum RRF score threshold for filtering results (optional)')
+                                    ->defaultNull()
+                                ->end()
+                                ->booleanNode('normalize_scores')
+                                    ->info('Normalize scores to 0-100 range for better readability')
+                                    ->defaultTrue()
+                                ->end()
+                                ->floatNode('fuzzy_primary_threshold')
+                                    ->info('Primary threshold for fuzzy matching (pg_trgm word_similarity). Higher = stricter. Default: 0.25')
+                                    ->defaultValue(0.25)
+                                    ->min(0.0)
+                                    ->max(1.0)
+                                ->end()
+                                ->floatNode('fuzzy_secondary_threshold')
+                                    ->info('Secondary threshold for fuzzy matching with double validation. Catches more typos. Default: 0.2')
+                                    ->defaultValue(0.2)
+                                    ->min(0.0)
+                                    ->max(1.0)
+                                ->end()
+                                ->floatNode('fuzzy_strict_threshold')
+                                    ->info('Strict similarity threshold for double validation to eliminate false positives. Default: 0.15')
+                                    ->defaultValue(0.15)
+                                    ->min(0.0)
+                                    ->max(1.0)
+                                ->end()
+                                ->floatNode('fuzzy_weight')
+                                    ->info('Weight of fuzzy matching vs FTS in hybrid search. 0.0 = disabled, 0.5 = equal (recommended), 1.0 = fuzzy only')
+                                    ->defaultValue(0.5)
+                                    ->min(0.0)
+                                    ->max(1.0)
+                                ->end()
+                                ->arrayNode('searchable_attributes')
+                                    ->info('Searchable attributes with field-specific boosting (similar to Meilisearch). Each attribute creates a separate tsvector column.')
+                                    ->useAttributeAsKey('name')
+                                    ->arrayPrototype()
+                                        ->children()
+                                            ->floatNode('boost')
+                                                ->info('Boost multiplier for this field (e.g., 2.0 = twice as important). Default: 1.0')
+                                                ->defaultValue(1.0)
+                                                ->min(0.0)
+                                            ->end()
+                                            ->scalarNode('metadata_key')
+                                                ->info('JSON path to extract value from metadata (e.g., "title", "description")')
+                                                ->isRequired()
+                                                ->cannotBeEmpty()
+                                            ->end()
+                                        ->end()
+                                    ->end()
+                                ->end()
                                 ->stringNode('dbal_connection')->cannotBeEmpty()->end()
                             ->end()
                             ->validate()

src/ai-bundle/src/AiBundle.php

@@ -1432,6 +1432,38 @@ private function processStoreConfig(string $type, array $stores, ContainerBuilde
                     $arguments[8] = $store['default_max_score'];
                 }
 
+                if (\array_key_exists('default_min_score', $store)) {
+                    $arguments[9] = $store['default_min_score'];
+                }
+
+                if (\array_key_exists('normalize_scores', $store)) {
+                    $arguments[10] = $store['normalize_scores'];
+                }
+
+                if (\array_key_exists('fuzzy_primary_threshold', $store)) {
+                    $arguments[11] = $store['fuzzy_primary_threshold'];
+                }
+
+                if (\array_key_exists('fuzzy_secondary_threshold', $store)) {
+                    $arguments[12] = $store['fuzzy_secondary_threshold'];
+                }
+
+                if (\array_key_exists('fuzzy_strict_threshold', $store)) {
+                    $arguments[13] = $store['fuzzy_strict_threshold'];
+                }
+
+                if (\array_key_exists('fuzzy_weight', $store)) {
+                    $arguments[14] = $store['fuzzy_weight'];
+                }
+
+                if (\array_key_exists('searchable_attributes', $store)) {
+                    $arguments[15] = $store['searchable_attributes'];
+                }
+
+                if (\array_key_exists('bm25_language', $store)) {
+                    $arguments[16] = $store['bm25_language'];
+                }
+
                 $definition
                     ->addTag('ai.store')
                     ->setArguments($arguments);