impr (cli + hql): fixing upserts, updates, and unique edges + improving CLI init command (#880)

<!-- greptile_comment -->

<h3>Greptile Summary</h3>

This PR fixes three core correctness issues — unique edge enforcement,
update-from-variable codegen, and upsert default-value handling — and
improves the CLI `init` command.

**Key changes:**
- **`add_e.rs`**: Rewrites unique-edge enforcement from the overly
strict `PutFlags::NO_OVERWRITE` (which blocked any second same-label
edge from a node regardless of target) to an explicit scan of existing
`out_edges_db` entries. The new logic correctly enforces uniqueness only
on the `(from, label, to)` triple. Tests confirm multiple targets and
sources are allowed.
- **`upsert.rs` / `traversal_steps.rs` / `traversal_validation.rs`**:
Adds `upsert_*_with_defaults` variants that apply schema-defined
`DEFAULT` values only during creation; updates correctly ignore them.
The code generator now emits `upsert_*_with_defaults(...)` calls with
defaults extracted from schema at analysis time. `TraversalType::Update`
refactored to carry `source`/`source_is_plural`, enabling direct
variable-to-update codegen without an intermediate read-only traversal.
- **`init.rs`**: Changes `.gitignore` creation from unconditional
overwrite to append with line deduplication. However, two bugs remain:
(1) unconditional cleanup tracking even when file pre-existed, risking
deletion of user content on failure; (2) no guard newline when appending
to files lacking a trailing newline, potentially corrupting the last
entry.
- **Test additions**: New unit tests for unique-edge semantics,
`upsert_*_with_defaults` behaviour, and two HQL integration test suites
(`update_from_var`, `user_test_13`).

**Findings:**
- `.gitignore` append logic has two correctness issues that can result
in data loss or file corruption.

<details><summary><h3>Flowchart</h3></summary>

```mermaid
%%{init: {'theme': 'neutral'}}%%
flowchart TD
    A["add_edge called"] --> B{is_unique flag set?}
    B -->|Yes| C["Scan out_edges_db for from+label key"]
    C --> D{Duplicate to_node found?}
    D -->|Yes| E["Return DuplicateKey error"]
    D -->|No| F["Allocate Edge with v6 UUID"]
    B -->|No| F
    F --> G["Write to edges_db with APPEND"]
    G --> H["Write to out_edges_db with APPEND_DUP"]
    H --> I["Write to in_edges_db with APPEND_DUP"]
    I --> J["Return Ok with Edge value"]

    K["upsert_n_with_defaults called"] --> L{Iterator yields item?}
    L -->|Node exists| M["Update path: apply props only\nignore create_defaults"]
    L -->|Empty iterator| N["Create path: merge_create_props\nprops take priority over defaults"]
    L -->|Error| O["Propagate error"]
    N --> P["Insert new node with merged props"]
    M --> Q["Persist updated node"]

    R["UPDATE from variable"] --> S{Source variable type?}
    S -->|Single node var| T["G::new_mut_from with cloned var"]
    S -->|Collection var| U["G::new_mut_from_iter with cloned iter"]
    S -->|Inline traversal| V["Read-only traversal first then write"]
    T --> W[".update then collect_to_obj"]
    U --> W
    V --> W
```
</details>


<sub>Last reviewed commit: 4e46111</sub>

<!-- greptile_other_comments_section -->

<!-- /greptile_comment -->

Author: xav-db

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "helix-cli"
-version = "2.3.1"
+version = "2.3.2"
 edition = "2024"
 
 [dependencies]

helix-cli/Cargo.toml

@@ -16,6 +16,7 @@ use eyre::Result;
 use std::collections::HashMap;
 use std::env;
 use std::fs;
+use std::io::Write;
 use std::path::Path;
 
 pub async fn run(
@@ -338,14 +339,36 @@ fn create_project_structure(
     fs::write(&queries_path_file, default_queries)?;
     cleanup_tracker.track_file(queries_path_file);
 
-    // Create .gitignore
-    let gitignore = r#".helix/
-target/
-*.log
-"#;
+    // add this to .gitignore
+    let gitignore = [".helix/", "target/", "*.log"];
     let gitignore_path = project_dir.join(".gitignore");
-    fs::write(&gitignore_path, gitignore)?;
-    cleanup_tracker.track_file(gitignore_path);
+    let file_existed = gitignore_path.exists();
+    let existing = fs::read_to_string(&gitignore_path).unwrap_or_default();
+
+    let missing_entries: Vec<&str> = gitignore
+        .iter()
+        .copied()
+        .filter(|entry| !existing.lines().any(|line| line.trim() == *entry))
+        .collect();
+
+    if !missing_entries.is_empty() {
+        let mut file = fs::OpenOptions::new()
+            .create(true)
+            .append(true)
+            .open(&gitignore_path)?;
+
+        if !existing.is_empty() && !existing.ends_with('\n') {
+            writeln!(file)?;
+        }
+
+        for entry in missing_entries {
+            writeln!(file, "{entry}")?;
+        }
+    }
+
+    if !file_existed {
+        cleanup_tracker.track_file(gitignore_path);
+    }
 
     Ok(())
 }

helix-cli/src/commands/init.rs

@@ -42,6 +42,34 @@ pub struct HelixManager<'a> {
     project: &'a ProjectContext,
 }
 
+fn build_standard_deploy_payload(
+    schema_content: String,
+    queries_map: HashMap<String, String>,
+    cluster_name: &str,
+    cluster_info: &CloudInstanceConfig,
+    helix_toml_content: Option<String>,
+    build_mode_override: Option<String>,
+) -> Result<serde_json::Value> {
+    let build_mode = match cluster_info.build_mode {
+        BuildMode::Dev => "dev",
+        BuildMode::Release => "release",
+        BuildMode::Debug => {
+            return Err(eyre!("debug build mode is not supported for cloud deploys"));
+        }
+    };
+
+    Ok(json!({
+        "schema": schema_content,
+        "queries": queries_map,
+        "env_vars": cluster_info.env_vars.clone(),
+        "runtime_config": cluster_info.runtime_config(),
+        "build_mode": build_mode,
+        "instance_name": cluster_name,
+        "helix_toml": helix_toml_content,
+        "build_mode_override": build_mode_override,
+    }))
+}
+
 impl<'a> HelixManager<'a> {
     pub fn new(project: &'a ProjectContext) -> Self {
         Self { project }
@@ -58,7 +86,7 @@ impl<'a> HelixManager<'a> {
         let cluster_id = "YOUR_CLUSTER_ID".to_string();
 
         // Use provided region or default to us-east-1
-        let region = region.or_else(|| Some("us-east-1".to_string()));
+        let region = region.or(Some("us-east-1".to_string()));
 
         Ok(CloudInstanceConfig {
             cluster_id,
@@ -140,7 +168,7 @@ impl<'a> HelixManager<'a> {
         build_mode_override: Option<BuildMode>,
     ) -> Result<()> {
         let credentials = require_auth().await?;
-        let path = match get_path_or_cwd(path.as_ref()) {
+        let path = match get_path_or_cwd(path.as_deref()) {
             Ok(path) => path,
             Err(e) => {
                 return Err(eyre!("Error: failed to get path: {e}"));
@@ -241,22 +269,22 @@ impl<'a> HelixManager<'a> {
         // Prepare deployment payload
         let build_mode_override = build_mode_override
             .map(|mode| match mode {
-                BuildMode::Dev => Ok("dev"),
-                BuildMode::Release => Ok("release"),
+                BuildMode::Dev => Ok("dev".to_string()),
+                BuildMode::Release => Ok("release".to_string()),
                 BuildMode::Debug => {
                     Err(eyre!("debug build mode is not supported for cloud deploys"))
                 }
             })
             .transpose()?;
 
-        let payload = json!({
-            "schema": schema_content,
-            "queries": queries_map,
-            "env_vars": cluster_info.env_vars,
-            "instance_name": cluster_name,
-            "helix_toml": helix_toml_content,
-            "build_mode_override": build_mode_override
-        });
+        let payload = build_standard_deploy_payload(
+            schema_content,
+            queries_map,
+            &cluster_name,
+            cluster_info,
+            helix_toml_content,
+            build_mode_override,
+        )?;
 
         // Initiate deployment with SSE streaming
         let client = reqwest::Client::new();
@@ -525,7 +553,7 @@ impl<'a> HelixManager<'a> {
         config: &crate::config::EnterpriseInstanceConfig,
     ) -> Result<()> {
         let credentials = require_auth().await?;
-        let path = match get_path_or_cwd(path.as_ref()) {
+        let path = match get_path_or_cwd(path.as_deref()) {
             Ok(path) => path,
             Err(e) => {
                 return Err(eyre!("Error: failed to get path: {e}"));
@@ -540,8 +568,7 @@ impl<'a> HelixManager<'a> {
             for entry in std::fs::read_dir(&queries_dir)? {
                 let entry = entry?;
                 let file_path = entry.path();
-                if file_path.is_file() && file_path.extension().map(|e| e == "rs").unwrap_or(false)
-                {
+                if file_path.is_file() && file_path.extension().is_some_and(|e| e == "rs") {
                     let filename = file_path.file_name().unwrap().to_string_lossy().to_string();
                     let content = std::fs::read_to_string(&file_path)
                         .map_err(|e| eyre!("Failed to read {}: {}", filename, e))?;
@@ -682,9 +709,54 @@ impl<'a> HelixManager<'a> {
 }
 
 /// Returns the path or the current working directory if no path is provided
-pub fn get_path_or_cwd(path: Option<&String>) -> Result<PathBuf> {
+pub fn get_path_or_cwd(path: Option<&str>) -> Result<PathBuf> {
     match path {
         Some(p) => Ok(PathBuf::from(p)),
         None => Ok(env::current_dir()?),
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn build_standard_deploy_payload_includes_runtime_config_and_build_mode() {
+        let mut queries = HashMap::new();
+        queries.insert("search.hx".to_string(), "GetUsers {}".to_string());
+
+        let mut env_vars = HashMap::new();
+        env_vars.insert("OPENAI_API_KEY".to_string(), "key".to_string());
+
+        let config = CloudInstanceConfig {
+            cluster_id: "cluster-123".to_string(),
+            region: Some("us-east-1".to_string()),
+            build_mode: BuildMode::Release,
+            env_vars,
+            db_config: DbConfig {
+                vector_config: crate::config::VectorConfig {
+                    db_max_size_gb: 42,
+                    ..Default::default()
+                },
+                ..Default::default()
+            },
+        };
+
+        let payload = build_standard_deploy_payload(
+            "schema.hx".to_string(),
+            queries,
+            "prod",
+            &config,
+            Some("[project]\nname = \"demo\"\n".to_string()),
+            Some("dev".to_string()),
+        )
+        .expect("payload should serialize");
+
+        assert_eq!(payload["build_mode"], "release");
+        assert_eq!(payload["build_mode_override"], "dev");
+        assert_eq!(payload["instance_name"], "prod");
+        assert_eq!(payload["env_vars"]["OPENAI_API_KEY"], "key");
+        assert_eq!(payload["runtime_config"]["db_max_size_gb"], 42);
+        assert!(payload["helix_toml"].is_string());
+    }
+}