feat(search): infer --type and --column from indexes; default schema to public

Make --type and --column optional in hotdata search. When either is
omitted, the CLI fetches the table indexes, filters to searchable
types (bm25/vector), and resolves them automatically. Exits with a
clear error when the result is ambiguous or no index exists.

Accept connection.table as shorthand for connection.public.table
in --table; schema defaults to public when omitted.

Before:
  hotdata search query --type bm25 --table airbnb.public.listings --column description --limit 5

After:
  hotdata search query --table airbnb.listings --limit 5

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: eddietejeda

src/command.rs

@@ -158,24 +158,28 @@ pub enum Commands {
         /// Search query text — required for both --type bm25 and --type vector
         query: String,
 
-        /// Search type — required (no default; choose deliberately)
+        /// Search type (`bm25` or `vector`). Inferred automatically when the table has exactly
+        /// one search index — required only when multiple indexes exist.
         ///
         /// `vector` runs server-side `vector_distance(col, 'text')` — the server resolves the
         /// embedding column, model, and metric from the index metadata.
         ///
         /// `bm25` runs server-side `bm25_search(table, col, 'text')` and requires a BM25 index
         /// on the column.
         #[arg(long, value_parser = ["vector", "bm25"])]
-        r#type: String,
+        r#type: Option<String>,
 
-        /// Table to search (connection.schema.table)
+        /// Table to search (`connection.table` or `connection.schema.table`).
+        /// Schema defaults to `public` when omitted.
         #[arg(long)]
         table: String,
 
-        /// Column to search. For `--type vector`, name the source text column — the server
-        /// resolves the embedding column from the index metadata.
+        /// Column to search. Inferred automatically when the table has exactly one search index
+        /// of the resolved type — required only when multiple indexed columns exist.
+        /// For `--type vector`, name the source text column — the server resolves the embedding
+        /// column from the index metadata.
         #[arg(long)]
-        column: String,
+        column: Option<String>,
 
         /// Columns to display (comma-separated, defaults to all)
         #[arg(long)]

src/indexes.rs

@@ -147,6 +147,91 @@ fn list_one_table_scan(
     }
 }
 
+/// Infers `(index_type, column)` for `hotdata search` when `--type` or `--column` are omitted.
+///
+/// Fetches the indexes on `connection_name.schema.table`, filters to searchable types
+/// (`bm25`, `vector`), and narrows further by `hint_type` / `hint_column` when provided.
+/// Exits with an error when the result is ambiguous (multiple matches) or no index exists.
+pub fn infer_for_search(
+    workspace_id: &str,
+    connection_name: &str,
+    schema: &str,
+    table: &str,
+    hint_type: Option<&str>,
+    hint_column: Option<&str>,
+) -> (String, String) {
+    use crossterm::style::Stylize;
+
+    let api = ApiClient::new(Some(workspace_id));
+
+    // Resolve connection name → ID
+    let conn_map = connection_lookup(&api);
+    let connection_id = match conn_map.get(connection_name) {
+        Some(id) => id.clone(),
+        None => {
+            eprintln!(
+                "{}",
+                format!("Connection '{}' not found.", connection_name).red()
+            );
+            std::process::exit(1);
+        }
+    };
+
+    // Fetch indexes for this table
+    let indexes = list_one_table(&api, &connection_id, schema, table);
+
+    // Filter to searchable indexes, honouring any hints
+    let matches: Vec<&Index> = indexes
+        .iter()
+        .filter(|i| {
+            let t = i.index_type.as_str();
+            (t == "bm25" || t == "vector")
+                && hint_type.map_or(true, |ht| ht == t)
+                && hint_column.map_or(true, |hc| i.columns.iter().any(|c| c == hc))
+        })
+        .collect();
+
+    match matches.as_slice() {
+        [] => {
+            let what = match hint_type {
+                Some(t) => format!("{} index", t),
+                None => "BM25 or vector index".to_string(),
+            };
+            eprintln!(
+                "{}",
+                format!(
+                    "No {} found on {}.{}.{} — run 'hotdata indexes create' first.",
+                    what, connection_name, schema, table
+                )
+                .red()
+            );
+            std::process::exit(1);
+        }
+        [one] => {
+            let index_type = one.index_type.clone();
+            let column = one.columns.first().cloned().unwrap_or_default();
+            (index_type, column)
+        }
+        _ => {
+            let types: Vec<&str> = matches.iter().map(|i| i.index_type.as_str()).collect();
+            let cols: Vec<String> = matches
+                .iter()
+                .flat_map(|i| i.columns.iter().cloned())
+                .collect();
+            eprintln!(
+                "{}",
+                format!(
+                    "Multiple search indexes found (types: {}, columns: {}) — specify --type and --column.",
+                    types.join(", "),
+                    cols.join(", ")
+                )
+                .red()
+            );
+            std::process::exit(1);
+        }
+    }
+}
+
 pub fn list(
     workspace_id: &str,
     connection_id: Option<&str>,

src/main.rs

@@ -706,9 +706,46 @@ fn main() {
                 output,
             } => {
                 let workspace_id = resolve_workspace(workspace_id);
+
+                // Parse `connection.table` or `connection.schema.table`.
+                // Schema defaults to `public` when omitted.
+                let parts: Vec<&str> = table.splitn(4, '.').collect();
+                let (conn_name, schema, table_name) = match parts.as_slice() {
+                    [conn, schema, tbl] => {
+                        (conn.to_string(), schema.to_string(), tbl.to_string())
+                    }
+                    [conn, tbl] => (conn.to_string(), "public".to_string(), tbl.to_string()),
+                    _ => {
+                        eprintln!(
+                            "error: --table must be 'connection.table' or 'connection.schema.table'"
+                        );
+                        std::process::exit(1);
+                    }
+                };
+                let normalized_table = format!("{}.{}.{}", conn_name, schema, table_name);
+
+                // Infer --type and --column from the table's indexes when either is omitted.
+                let (resolved_type, resolved_column) =
+                    if r#type.is_some() && column.is_some() {
+                        (r#type.unwrap(), column.unwrap())
+                    } else {
+                        let (inferred_type, inferred_column) = indexes::infer_for_search(
+                            &workspace_id,
+                            &conn_name,
+                            &schema,
+                            &table_name,
+                            r#type.as_deref(),
+                            column.as_deref(),
+                        );
+                        (
+                            r#type.unwrap_or(inferred_type),
+                            column.unwrap_or(inferred_column),
+                        )
+                    };
+
                 let select_cols = select.as_deref().unwrap_or("*");
 
-                let sql = match r#type.as_str() {
+                let sql = match resolved_type.as_str() {
                     "bm25" => {
                         let bm25_columns = match select.as_deref() {
                             Some(cols) => format!("{}, score", cols),
@@ -717,8 +754,8 @@ fn main() {
                         format!(
                             "SELECT {} FROM bm25_search('{}', '{}', '{}') ORDER BY score DESC LIMIT {}",
                             bm25_columns,
-                            table.replace('\'', "''"),
-                            column.replace('\'', "''"),
+                            normalized_table.replace('\'', "''"),
+                            resolved_column.replace('\'', "''"),
                             query.replace('\'', "''"),
                             limit,
                         )
@@ -728,9 +765,9 @@ fn main() {
                     "vector" => format!(
                         "SELECT {}, vector_distance({}, '{}') AS dist FROM {} ORDER BY dist LIMIT {}",
                         select_cols,
-                        column,
+                        resolved_column,
                         query.replace('\'', "''"),
-                        table,
+                        normalized_table,
                         limit,
                     ),
                     _ => unreachable!(),