feat: add vector search support

android/src/main/java/com/cblreactnative/CollectionManagerVector.kt

@@ -0,0 +1,153 @@
+/**
+ * CollectionManagerVector.kt
+ * 
+ * Vector index support for Android/Kotlin implementation.
+ * This code should be integrated into CollectionManager.kt
+ */
+
+package com.cblreactnative
+
+import com.couchbase.lite.Collection
+import com.couchbase.lite.VectorIndexConfiguration
+import com.couchbase.lite.VectorEncoding
+import com.couchbase.lite.DistanceMetric
+import com.couchbase.lite.ScalarQuantizerType
+
+/**
+ * Creates a vector index on the specified collection.
+ * 
+ * This method handles the "vector" case in the createIndex switch/when statement.
+ * 
+ * @param indexName Name for the new index
+ * @param indexConfig Map containing vector index configuration
+ * @param collection The collection to create the index on
+ * @throws Exception if index creation fails
+ */
+fun createVectorIndex(
+    indexName: String,
+    indexConfig: Map<String, Any>,
+    collection: Collection
+) {
+    // Extract required parameters
+    val expression = indexConfig["expression"] as? String
+        ?: throw Exception("Vector index requires 'expression' parameter")
+
+    val dimensions = (indexConfig["dimensions"] as? Number)?.toLong()
+        ?: throw Exception("Vector index requires 'dimensions' parameter")
+
+    val centroids = (indexConfig["centroids"] as? Number)?.toLong()
+        ?: throw Exception("Vector index requires 'centroids' parameter")
+
+    // Create vector index configuration
+    val vectorConfig = VectorIndexConfiguration(expression, dimensions, centroids)
+
+    // Set distance metric
+    val metricStr = indexConfig["metric"] as? String
+    if (metricStr != null) {
+        vectorConfig.metric = when (metricStr) {
+            "cosine" -> DistanceMetric.COSINE
+            "euclidean" -> DistanceMetric.EUCLIDEAN
+            "euclideanSquared" -> DistanceMetric.EUCLIDEAN_SQUARED
+            "dot" -> DistanceMetric.DOT
+            else -> DistanceMetric.EUCLIDEAN_SQUARED // Default
+        }
+    }
+
+    // Set encoding
+    val encodingConfig = indexConfig["encoding"] as? Map<String, Any>
+    if (encodingConfig != null) {
+        val encodingType = encodingConfig["type"] as? String
+        vectorConfig.encoding = when (encodingType) {
+            "none" -> VectorEncoding.none()
+            "SQ" -> {
+                // Scalar Quantizer - determine type from config or default to SQ8
+                val sqType = encodingConfig["sqType"] as? String
+                when (sqType) {
+                    "SQ4" -> VectorEncoding.scalarQuantizer(ScalarQuantizerType.SQ4)
+                    "SQ6" -> VectorEncoding.scalarQuantizer(ScalarQuantizerType.SQ6)
+                    "SQ8" -> VectorEncoding.scalarQuantizer(ScalarQuantizerType.SQ8)
+                    else -> VectorEncoding.scalarQuantizer(ScalarQuantizerType.SQ8)
+                }
+            }
+            "PQ" -> {
+                // Product Quantizer
+                val subquantizers = (encodingConfig["subquantizers"] as? Number)?.toLong() ?: 0
+                val bits = (encodingConfig["bits"] as? Number)?.toLong() ?: 8
+                VectorEncoding.productQuantizer(subquantizers, bits)
+            }
+            else -> VectorEncoding.none()
+        }
+    }
+
+    // Set optional training parameters
+    val minTrainingSize = (indexConfig["minTrainingSize"] as? Number)?.toLong()
+    if (minTrainingSize != null && minTrainingSize > 0) {
+        vectorConfig.minTrainingSize = minTrainingSize
+    }
+
+    val maxTrainingSize = (indexConfig["maxTrainingSize"] as? Number)?.toLong()
+    if (maxTrainingSize != null && maxTrainingSize > 0) {
+        vectorConfig.maxTrainingSize = maxTrainingSize
+    }
+
+    // Set number of probes (affects search accuracy vs speed)
+    val numProbes = (indexConfig["numProbes"] as? Number)?.toLong()
+    if (numProbes != null && numProbes > 0) {
+        vectorConfig.numProbes = numProbes
+    }
+
+    // Set lazy indexing (index built on first query)
+    val isLazy = indexConfig["isLazy"] as? Boolean
+    if (isLazy != null) {
+        vectorConfig.isLazy = isLazy
+    }
+
+    // Create the index
+    collection.createIndex(indexName, vectorConfig)
+}
+
+/*
+ * INTEGRATION INSTRUCTIONS
+ * ========================
+ * 
+ * To integrate this into CollectionManager.kt:
+ * 
+ * 1. Add the imports at the top of the file:
+ * 
+ *    import com.couchbase.lite.VectorIndexConfiguration
+ *    import com.couchbase.lite.VectorEncoding
+ *    import com.couchbase.lite.DistanceMetric
+ *    import com.couchbase.lite.ScalarQuantizerType
+ * 
+ * 2. Modify the createIndex function signature to accept optional config:
+ * 
+ *    fun createIndex(
+ *        indexName: String,
+ *        indexType: String,
+ *        items: List<List<Any>>,
+ *        indexConfig: Map<String, Any>? = null,  // ADD THIS
+ *        collectionName: String,
+ *        scopeName: String,
+ *        databaseName: String
+ *    )
+ * 
+ * 3. Add the vector case to the when statement:
+ * 
+ *    when (indexType) {
+ *        "value" -> {
+ *            // existing code...
+ *        }
+ *        "full-text" -> {
+ *            // existing code...
+ *        }
+ *        "vector" -> {
+ *            val config = indexConfig
+ *                ?: throw Exception("Vector index requires config")
+ *            createVectorIndex(indexName, config, collection)
+ *        }
+ *        else -> throw Exception("Unknown index type: $indexType")
+ *    }
+ * 
+ * 4. Update the React Native bridge module (CblReactnativeModule.kt) to
+ *    extract and pass the full config map for vector indexes.
+ */