feat(autocomplete): quote non-simple jq field names in suggestions

- Adds identifier check + quoting for non‑simple keys (leading digits, hyphens, etc.)
- Updates array iteration suggestions to use .[]."field-name"
- Supports nesting too

Author: thn929

src/autocomplete/result_analyzer.rs

@@ -11,15 +11,38 @@ fn dot_prefix(needs_leading_dot: bool) -> &'static str {
 }
 
 impl ResultAnalyzer {
+    /// Check if a field name can use jq's simple dot syntax (e.g., .foo)
+    /// According to jq manual: "The .foo syntax only works for simple, identifier-like keys,
+    /// that is, keys that are all made of alphanumeric characters and underscore,
+    /// and which do not start with a digit."
+    /// (https://jqlang.org/manual/#object-identifier-index)
+    /// Names that don't fit require quoted access: ."field-name"
+    fn is_simple_jq_identifier(name: &str) -> bool {
+        if name.is_empty() {
+            return false;
+        }
+        let first_char = name.chars().next().unwrap();
+        !first_char.is_numeric() && name.chars().all(|c| c.is_alphanumeric() || c == '_')
+    }
+
+    /// Format a field name for jq syntax, quoting if it doesn't fit simple dot syntax
+    fn format_field_name(prefix: &str, name: &str) -> String {
+        if Self::is_simple_jq_identifier(name) {
+            format!("{}{}", prefix, name)
+        } else {
+            format!("{}\"{}\"", prefix, name)
+        }
+    }
     fn extract_object_fields(
         map: &serde_json::Map<String, Value>,
         prefix: &str,
         suggestions: &mut Vec<Suggestion>,
     ) {
         for (key, val) in map {
             let field_type = Self::detect_json_type(val);
+            let field_text = Self::format_field_name(prefix, key);
             suggestions.push(Suggestion::new_with_type(
-                format!("{}{}", prefix, key),
+                field_text,
                 SuggestionType::Field,
                 Some(field_type),
             ));
@@ -67,9 +90,16 @@ impl ResultAnalyzer {
                     for (key, val) in map {
                         let field_type = Self::detect_json_type(val);
                         let field_text = if suppress_array_brackets {
-                            format!("{}{}", prefix, key)
+                            Self::format_field_name(prefix, key)
                         } else {
-                            format!("{}[].{}", prefix, key)
+                            // For array iteration syntax, quote non-simple identifiers
+                            if Self::is_simple_jq_identifier(key) {
+                                // Simple identifier: .[].fieldname
+                                format!("{}[].{}", prefix, key)
+                            } else {
+                                // Non-simple identifier (starts with digit, contains special chars): .[]."fieldname"
+                                format!("{}[].\"{}\"", prefix, key)
+                            }
                         };
                         suggestions.push(Suggestion::new_with_type(
                             field_text,
@@ -135,11 +165,16 @@ impl ResultAnalyzer {
                     for (key, val) in map {
                         let field_type = Self::detect_json_type(val);
                         // When suppressing brackets, suggest ".field"
-                        // Otherwise, suggest ".[].field"
+                        // Otherwise, suggest ".[].field" with quoting if needed
                         let field_text = if suppress_array_brackets {
-                            format!("{}{}", prefix, key)
+                            Self::format_field_name(prefix, key)
                         } else {
-                            format!("{}[].{}", prefix, key)
+                            // Apply quoting logic for array iteration
+                            if Self::is_simple_jq_identifier(key) {
+                                format!("{}[].{}", prefix, key)
+                            } else {
+                                format!("{}[].\"{}\"", prefix, key)
+                            }
                         };
                         suggestions.push(Suggestion::new_with_type(
                             field_text,

src/autocomplete/result_analyzer_tests.rs

@@ -822,3 +822,168 @@ mod analyze_value_tests {
         assert_eq!(suggestions[0].text, ".field");
     }
 }
+
+// ============================================================================
+// Nonsimple Field Name Quoting Tests
+// ============================================================================
+
+#[test]
+fn test_field_starting_with_digit_gets_quoted() {
+    let json: Value = serde_json::from_str(r#"{"1numeric_key": "value"}"#).unwrap();
+    let suggestions = ResultAnalyzer::analyze_value(&json, true, false);
+
+    assert_eq!(suggestions.len(), 1);
+    assert_eq!(suggestions[0].text, r#"."1numeric_key""#);
+}
+
+#[test]
+fn test_field_with_hyphen_gets_quoted() {
+    let json: Value = serde_json::from_str(r#"{"my-field": "value"}"#).unwrap();
+    let suggestions = ResultAnalyzer::analyze_value(&json, true, false);
+
+    assert_eq!(suggestions.len(), 1);
+    assert_eq!(suggestions[0].text, r#"."my-field""#);
+}
+
+#[test]
+fn test_valid_field_name_not_quoted() {
+    let json: Value = serde_json::from_str(r#"{"simple_key": "value"}"#).unwrap();
+    let suggestions = ResultAnalyzer::analyze_value(&json, true, false);
+
+    assert_eq!(suggestions.len(), 1);
+    assert_eq!(suggestions[0].text, ".simple_key");
+}
+
+#[test]
+fn test_multiple_fields_with_mixed_identifier_types() {
+    let json: Value =
+        serde_json::from_str(r#"{"simple_key": 1, "1numeric_key": 2, "hyphen-key": 3}"#).unwrap();
+    let suggestions = ResultAnalyzer::analyze_value(&json, true, false);
+
+    assert_eq!(suggestions.len(), 3);
+    let suggestion_texts: Vec<_> = suggestions.iter().map(|s| s.text.as_str()).collect();
+    assert!(suggestion_texts.contains(&".simple_key"));
+    assert!(suggestion_texts.contains(&r#"."1numeric_key""#));
+    assert!(suggestion_texts.contains(&r#"."hyphen-key""#));
+}
+
+#[test]
+fn test_array_of_objects_with_nonsimple_field_names() {
+    let json: Value = serde_json::from_str(
+        r#"[{"1numeric_key": "value1", "simple_key": "value2"}, {"1numeric_key": "value3", "simple_key": "value4"}]"#,
+    )
+    .unwrap();
+    let suggestions = ResultAnalyzer::analyze_value(&json, true, false);
+
+    assert_eq!(suggestions.len(), 3); // .[], .[].1numeric_key, .[].simple_key
+    let suggestion_texts: Vec<_> = suggestions.iter().map(|s| s.text.as_str()).collect();
+    assert!(suggestion_texts.contains(&".[]"));
+    assert!(suggestion_texts.contains(&r#".[]."1numeric_key""#));
+    assert!(suggestion_texts.contains(&".[].simple_key"));
+}
+
+#[test]
+fn test_no_leading_dot_with_nonsimple_field() {
+    let json: Value = serde_json::from_str(r#"{"1numeric_key": "value"}"#).unwrap();
+    let suggestions = ResultAnalyzer::analyze_value(&json, false, false);
+
+    assert_eq!(suggestions.len(), 1);
+    assert_eq!(suggestions[0].text, r#""1numeric_key""#);
+}
+
+// ============================================================================
+// Complex Nested Scenarios Tests
+// ============================================================================
+
+#[test]
+fn test_nested_array_name_quoting_across_levels() {
+    // Scenario: ."hyphen-array"[]."nested-items"[] with nested array names
+    let json: Value = serde_json::from_str(
+        r#"{
+            "hyphen-array": [
+                {
+                    "nested-items": [
+                        {"simple_key": "value"}
+                    ]
+                }
+            ]
+        }"#,
+    )
+    .unwrap();
+
+    let top_level = ResultAnalyzer::analyze_value(&json, true, false);
+    assert!(top_level.iter().any(|s| s.text == r#"."hyphen-array""#));
+    assert!(!top_level.iter().any(|s| s.text == ".hyphen-array"));
+
+    let outer_array = json
+        .get("hyphen-array")
+        .and_then(Value::as_array)
+        .expect("outer array should exist");
+    let outer_obj = outer_array
+        .first()
+        .and_then(Value::as_object)
+        .expect("outer array should contain object");
+    let outer_obj_value = Value::Object(outer_obj.clone());
+    let nested_level = ResultAnalyzer::analyze_value(&outer_obj_value, true, false);
+    assert!(nested_level.iter().any(|s| s.text == r#"."nested-items""#));
+    assert!(!nested_level.iter().any(|s| s.text == ".nested-items"));
+}
+
+#[test]
+fn test_nested_field_quoting_with_iteration() {
+    // Scenario: .outer[]."inner-array"[]."hyphen-key" and .[]."1numeric_key"
+    let json: Value = serde_json::from_str(
+        r#"{
+            "outer": [
+                {
+                    "inner-array": [
+                        {"hyphen-key": "v1", "1numeric_key": "v2", "simple_key": "v3"}
+                    ]
+                }
+            ]
+        }"#,
+    )
+    .unwrap();
+
+    let outer_array = json
+        .get("outer")
+        .and_then(Value::as_array)
+        .expect("outer array should exist");
+    let outer_obj = outer_array
+        .first()
+        .and_then(Value::as_object)
+        .expect("outer array should contain object");
+    let outer_obj_value = Value::Object(outer_obj.clone());
+    let outer_suggestions = ResultAnalyzer::analyze_value(&outer_obj_value, true, false);
+    assert!(
+        outer_suggestions
+            .iter()
+            .any(|s| s.text == r#"."inner-array""#)
+    );
+
+    let inner_array = outer_obj_value
+        .get("inner-array")
+        .and_then(Value::as_array)
+        .expect("inner array should exist");
+    let inner_array_value = Value::Array(inner_array.clone());
+    let inner_suggestions = ResultAnalyzer::analyze_value(&inner_array_value, true, false);
+
+    assert!(inner_suggestions.iter().any(|s| s.text == ".[]"));
+    assert!(
+        inner_suggestions
+            .iter()
+            .any(|s| s.text == r#".[]."hyphen-key""#)
+    );
+    assert!(
+        inner_suggestions
+            .iter()
+            .any(|s| s.text == r#".[]."1numeric_key""#)
+    );
+    assert!(inner_suggestions.iter().any(|s| s.text == ".[].simple_key"));
+    assert!(!inner_suggestions.iter().any(|s| s.text == ".[].hyphen-key"));
+    assert!(
+        !inner_suggestions
+            .iter()
+            .any(|s| s.text == ".[].1numeric_key")
+    );
+}