fix: address review feedback on dot-bracket notation

- Dataset auto-name now includes columns (dataset_{cols}_{type}) to avoid collision
- Validate bracket closure in parse_index_target; reject unclosed/garbled brackets
- Add quoting note to indexes create doc comment for shell glob safety
- resolve_connection_id tries GET /connections/{id} directly for conn* prefixed IDs
- Add unit tests for parse_db_target and parse_index_target (6 tests)

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

Author: eddietejeda

src/command.rs

@@ -330,6 +330,9 @@ pub enum IndexesCommands {
     Create {
         /// Table and columns to index: `connection.table[col1,col2]`
         /// or `connection.schema.table[col1,col2]`. Schema defaults to `public`.
+        ///
+        /// Quote the argument to prevent shell glob expansion:
+        /// `hotdata indexes create 'airbnb.listings[description]' --type bm25`
         #[arg(conflicts_with = "dataset_id")]
         target: Option<String>,
 

src/connections.rs

@@ -158,7 +158,20 @@ struct ListResponse {
 }
 
 /// Resolve a connection name or ID to a connection ID, exiting on failure.
+///
+/// If `name_or_id` looks like a raw connection ID (starts with "conn"), tries
+/// `GET /connections/{id}` directly first to avoid listing the full workspace.
+/// Falls back to listing and matching by name on a 404 or when given a plain name.
 pub fn resolve_connection_id(api: &ApiClient, name_or_id: &str) -> String {
+    use crossterm::style::Stylize;
+
+    if name_or_id.starts_with("conn") {
+        let (status, _) = api.get_raw(&format!("/connections/{name_or_id}"));
+        if status.is_success() {
+            return name_or_id.to_string();
+        }
+    }
+
     let body: ListResponse = api.get("/connections");
     match body
         .connections
@@ -167,7 +180,6 @@ pub fn resolve_connection_id(api: &ApiClient, name_or_id: &str) -> String {
     {
         Some(conn) => conn.id.clone(),
         None => {
-            use crossterm::style::Stylize;
             eprintln!(
                 "{}",
                 format!("error: no connection named or with id '{name_or_id}'").red()

src/main.rs

@@ -621,7 +621,11 @@ fn main() {
                                             );
                                             std::process::exit(1);
                                         });
-                                    let auto = format!("dataset_{type}", type = r#type);
+                                    let auto = format!(
+                                        "dataset_{cols}_{type}",
+                                        cols = cols.replace(',', "_"),
+                                        type = r#type
+                                    );
                                     (
                                         (did.to_string(), String::new(), String::new()),
                                         cols.to_string(),
@@ -984,8 +988,14 @@ fn parse_index_target(target: &str) -> (String, String, String, Vec<String>) {
         );
         std::process::exit(1);
     };
+    if !target.ends_with(']') {
+        eprintln!(
+            "error: target bracket is not closed — use e.g. 'airbnb.listings[col1,col2]'"
+        );
+        std::process::exit(1);
+    }
     let table_part = &target[..bracket_pos];
-    let cols_raw = target[bracket_pos + 1..].trim_end_matches(']');
+    let cols_raw = &target[bracket_pos + 1..target.len() - 1];
 
     let parts: Vec<&str> = table_part.splitn(4, '.').collect();
     let (conn, schema, table) = match parts.as_slice() {
@@ -1013,6 +1023,62 @@ fn parse_index_target(target: &str) -> (String, String, String, Vec<String>) {
     (conn, schema, table, columns)
 }
 
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // --- parse_db_target ---
+
+    #[test]
+    fn db_target_two_parts_defaults_schema_to_public() {
+        let (db, schema, table) = parse_db_target("airbnb.listings");
+        assert_eq!(db, "airbnb");
+        assert_eq!(schema, "public");
+        assert_eq!(table, "listings");
+    }
+
+    #[test]
+    fn db_target_three_parts_uses_explicit_schema() {
+        let (db, schema, table) = parse_db_target("airbnb.staging.listings");
+        assert_eq!(db, "airbnb");
+        assert_eq!(schema, "staging");
+        assert_eq!(table, "listings");
+    }
+
+    // --- parse_index_target ---
+
+    #[test]
+    fn index_target_two_parts_defaults_schema_to_public() {
+        let (conn, schema, table, cols) = parse_index_target("airbnb.listings[description]");
+        assert_eq!(conn, "airbnb");
+        assert_eq!(schema, "public");
+        assert_eq!(table, "listings");
+        assert_eq!(cols, vec!["description"]);
+    }
+
+    #[test]
+    fn index_target_three_parts_uses_explicit_schema() {
+        let (conn, schema, table, cols) =
+            parse_index_target("airbnb.public.listings[name,description]");
+        assert_eq!(conn, "airbnb");
+        assert_eq!(schema, "public");
+        assert_eq!(table, "listings");
+        assert_eq!(cols, vec!["name", "description"]);
+    }
+
+    #[test]
+    fn index_target_multiple_columns() {
+        let (_, _, _, cols) = parse_index_target("db.tbl[a,b,c]");
+        assert_eq!(cols, vec!["a", "b", "c"]);
+    }
+
+    #[test]
+    fn index_target_trims_column_whitespace() {
+        let (_, _, _, cols) = parse_index_target("db.tbl[a, b]");
+        assert_eq!(cols, vec!["a", "b"]);
+    }
+}
+
 pub fn get_styles() -> clap::builder::Styles {
     Styles::styled()
         .header(AnsiColor::Yellow.on_default())