tokensave 7.13.0

//! File editing tool handlers: `str_replace`, `multi_str_replace`, `insert_at`,
//! `ast_grep_rewrite`.

use serde_json::{json, Value};

use crate::errors::{Result, TokenSaveError};
use crate::tokensave::TokenSave;

use super::super::ToolResult;

/// Extracts the optional `project_root` (alias: `cwd`) parameter shared by
/// every edit tool. When present, it retargets resolution of a *relative*
/// `path`/symbol-file argument to this directory instead of the indexed
/// project root — the fix for callers working in a git worktree, where a
/// bare relative path previously always resolved against the primary
/// checkout regardless of where the caller was actually working.
fn project_root_arg(args: &Value) -> Option<&str> {
    args.get("project_root")
        .or_else(|| args.get("cwd"))
        .and_then(|v| v.as_str())
}

pub(super) async fn handle_str_replace(cg: &TokenSave, args: Value) -> Result<ToolResult> {
    let path = args
        .get("path")
        .and_then(|v| v.as_str())
        .ok_or_else(|| TokenSaveError::Config {
            message: "missing required parameter: path".to_string(),
        })?;

    let old_str = args
        .get("old_str")
        .and_then(|v| v.as_str())
        .ok_or_else(|| TokenSaveError::Config {
            message: "missing required parameter: old_str".to_string(),
        })?;

    let new_str = args
        .get("new_str")
        .and_then(|v| v.as_str())
        .ok_or_else(|| TokenSaveError::Config {
            message: "missing required parameter: new_str".to_string(),
        })?;

    let echo = args
        .get("echo")
        .and_then(serde_json::Value::as_bool)
        .unwrap_or(false);

    let root_override = project_root_arg(&args);
    let result = cg
        .str_replace(path, old_str, new_str, root_override)
        .await?;
    let touched_files = vec![result.file_path.clone()];
    let mut value = json!({
        "ok": result.success,
        "file": path,
    });
    if result.success {
        value["lines"] = json!([result.changed_lines.0, result.changed_lines.1]);
        value["digest"] = json!(result.digest);
        if echo {
            value["matched_str"] = json!(result.matched_str);
            value["new_str"] = json!(result.new_str);
        }
    } else {
        value["message"] = json!(result.message);
        // A "write landed but reindex failed" result carries the post-edit
        // digest so the caller can verify the file instead of retrying (#563).
        if !result.digest.is_empty() {
            value["digest"] = json!(result.digest);
        }
        if let Some(nearest) = result.nearest {
            value["nearest"] = json!(nearest);
        }
    }
    Ok(ToolResult {
        value: json!({
            "content": [{ "type": "text", "text": serde_json::to_string_pretty(&value).unwrap_or_default() }]
        }),
        touched_files,
    })
}

pub(super) async fn handle_multi_str_replace(cg: &TokenSave, args: Value) -> Result<ToolResult> {
    let path = args
        .get("path")
        .and_then(|v| v.as_str())
        .ok_or_else(|| TokenSaveError::Config {
            message: "missing required parameter: path".to_string(),
        })?;

    let replacements = args
        .get("replacements")
        .and_then(|v| v.as_array())
        .ok_or_else(|| TokenSaveError::Config {
            message: "missing required parameter: replacements".to_string(),
        })?;

    let parsed_replacements: Vec<(&str, &str)> = replacements
        .iter()
        .filter_map(|pair| {
            let arr = pair.as_array()?;
            if arr.len() != 2 {
                return None;
            }
            let old = arr[0].as_str()?;
            let new = arr[1].as_str()?;
            Some((old, new))
        })
        .collect();

    if parsed_replacements.len() != replacements.len() {
        return Err(TokenSaveError::Config {
            message: "each replacement must be an array of exactly 2 strings".to_string(),
        });
    }

    let root_override = project_root_arg(&args);
    let result = cg
        .multi_str_replace(path, &parsed_replacements, root_override)
        .await?;
    let touched_files = vec![result.file_path.clone()];
    Ok(ToolResult {
        value: json!({
            "content": [{ "type": "text", "text": serde_json::to_string_pretty(&result).unwrap_or_default() }]
        }),
        touched_files,
    })
}

pub(super) async fn handle_insert_at(cg: &TokenSave, args: Value) -> Result<ToolResult> {
    let path = args
        .get("path")
        .and_then(|v| v.as_str())
        .ok_or_else(|| TokenSaveError::Config {
            message: "missing required parameter: path".to_string(),
        })?;

    let anchor =
        args.get("anchor")
            .and_then(|v| v.as_str())
            .ok_or_else(|| TokenSaveError::Config {
                message: "missing required parameter: anchor".to_string(),
            })?;

    let content = args
        .get("content")
        .and_then(|v| v.as_str())
        .ok_or_else(|| TokenSaveError::Config {
            message: "missing required parameter: content".to_string(),
        })?;

    let before = args
        .get("before")
        .and_then(serde_json::Value::as_bool)
        .unwrap_or(false);

    let echo = args
        .get("echo")
        .and_then(serde_json::Value::as_bool)
        .unwrap_or(false);

    let root_override = project_root_arg(&args);
    let result = cg
        .insert_at(path, anchor, content, before, root_override)
        .await?;
    let touched_files = vec![result.file_path.clone()];
    let mut value = json!({
        "ok": result.success,
        "file": result.file_path,
    });
    if result.success {
        value["lines"] = json!([result.changed_lines.0, result.changed_lines.1]);
        value["digest"] = json!(result.digest);
        if echo {
            value["content"] = json!(result.content);
        }
    } else {
        value["message"] = json!(result.message);
        if let Some(nearest) = result.nearest {
            value["nearest"] = json!(nearest);
        }
    }
    Ok(ToolResult {
        value: json!({
            "content": [{ "type": "text", "text": serde_json::to_string_pretty(&value).unwrap_or_default() }]
        }),
        touched_files,
    })
}

pub(super) async fn handle_delete_symbol(cg: &TokenSave, args: Value) -> Result<ToolResult> {
    let symbol =
        args.get("symbol")
            .and_then(|v| v.as_str())
            .ok_or_else(|| TokenSaveError::Config {
                message: "missing required parameter: symbol".to_string(),
            })?;
    let include_doc_comment = args
        .get("include_doc_comment")
        .and_then(serde_json::Value::as_bool)
        .unwrap_or(true);
    let root_override = project_root_arg(&args);
    let result = cg
        .delete_symbol(symbol, include_doc_comment, root_override)
        .await?;
    let touched_files = if result.success {
        vec![result.file_path.clone()]
    } else {
        vec![]
    };
    let mut value = json!({ "ok": result.success, "file": result.file_path });
    if result.success {
        value["lines"] = json!([result.changed_lines.0, result.changed_lines.1]);
        value["digest"] = json!(result.digest);
    } else {
        value["message"] = json!(result.message);
    }
    Ok(ToolResult {
        value: json!({
            "content": [{ "type": "text", "text": serde_json::to_string_pretty(&value).unwrap_or_default() }]
        }),
        touched_files,
    })
}

pub(super) async fn handle_replace_lines(cg: &TokenSave, args: Value) -> Result<ToolResult> {
    let path = args
        .get("path")
        .and_then(|v| v.as_str())
        .ok_or_else(|| TokenSaveError::Config {
            message: "missing required parameter: path".to_string(),
        })?;
    let start = args
        .get("start")
        .and_then(serde_json::Value::as_u64)
        .ok_or_else(|| TokenSaveError::Config {
            message: "missing required parameter: start".to_string(),
        })? as u32;
    let end = args
        .get("end")
        .and_then(serde_json::Value::as_u64)
        .ok_or_else(|| TokenSaveError::Config {
            message: "missing required parameter: end".to_string(),
        })? as u32;
    let new_content = args
        .get("new_content")
        .and_then(|v| v.as_str())
        .ok_or_else(|| TokenSaveError::Config {
            message: "missing required parameter: new_content".to_string(),
        })?;
    let expected_digest = args.get("expected_digest").and_then(|v| v.as_str());
    let root_override = project_root_arg(&args);
    let result = cg
        .replace_lines(
            path,
            start,
            end,
            new_content,
            expected_digest,
            root_override,
        )
        .await?;
    let touched_files = if result.success {
        vec![result.file_path.clone()]
    } else {
        vec![]
    };
    let mut value = json!({ "ok": result.success, "file": path });
    if result.success {
        value["lines"] = json!([result.changed_lines.0, result.changed_lines.1]);
        value["digest"] = json!(result.digest);
    } else {
        value["message"] = json!(result.message);
    }
    Ok(ToolResult {
        value: json!({
            "content": [{ "type": "text", "text": serde_json::to_string_pretty(&value).unwrap_or_default() }]
        }),
        touched_files,
    })
}

pub(super) async fn handle_replace_symbol(cg: &TokenSave, args: Value) -> Result<ToolResult> {
    let symbol =
        args.get("symbol")
            .and_then(|v| v.as_str())
            .ok_or_else(|| TokenSaveError::Config {
                message: "missing required parameter: symbol".to_string(),
            })?;
    let new_source = args
        .get("new_source")
        .and_then(|v| v.as_str())
        .ok_or_else(|| TokenSaveError::Config {
            message: "missing required parameter: new_source".to_string(),
        })?;

    let echo = args
        .get("echo")
        .and_then(serde_json::Value::as_bool)
        .unwrap_or(false);

    let root_override = project_root_arg(&args);
    let result = cg.replace_symbol(symbol, new_source, root_override).await?;
    let touched_files = if result.success {
        vec![result.file_path.clone()]
    } else {
        vec![]
    };
    let mut value = json!({
        "ok": result.success,
        "file": result.file_path,
    });
    if result.success {
        value["lines"] = json!([result.changed_lines.0, result.changed_lines.1]);
        value["digest"] = json!(result.digest);
        if echo {
            value["matched_str"] = json!(result.matched_str);
            value["new_str"] = json!(result.new_str);
        }
    } else {
        value["message"] = json!(result.message);
        if let Some(nearest) = result.nearest {
            value["nearest"] = json!(nearest);
        }
    }
    Ok(ToolResult {
        value: json!({
            "content": [{ "type": "text", "text": serde_json::to_string_pretty(&value).unwrap_or_default() }]
        }),
        touched_files,
    })
}

pub(super) async fn handle_insert_at_symbol(cg: &TokenSave, args: Value) -> Result<ToolResult> {
    let symbol =
        args.get("symbol")
            .and_then(|v| v.as_str())
            .ok_or_else(|| TokenSaveError::Config {
                message: "missing required parameter: symbol".to_string(),
            })?;
    let content = args
        .get("content")
        .and_then(|v| v.as_str())
        .ok_or_else(|| TokenSaveError::Config {
            message: "missing required parameter: content".to_string(),
        })?;
    let position = args
        .get("position")
        .and_then(|v| v.as_str())
        .unwrap_or("after");

    let echo = args
        .get("echo")
        .and_then(serde_json::Value::as_bool)
        .unwrap_or(false);

    let root_override = project_root_arg(&args);
    let result = cg
        .insert_at_symbol(symbol, content, position, root_override)
        .await?;
    let touched_files = if result.success {
        vec![result.file_path.clone()]
    } else {
        vec![]
    };
    let mut value = json!({
        "ok": result.success,
        "file": result.file_path,
    });
    if result.success {
        value["lines"] = json!([result.changed_lines.0, result.changed_lines.1]);
        value["digest"] = json!(result.digest);
        if echo {
            value["content"] = json!(result.content);
        }
    } else {
        value["message"] = json!(result.message);
        if let Some(nearest) = result.nearest {
            value["nearest"] = json!(nearest);
        }
    }
    Ok(ToolResult {
        value: json!({
            "content": [{ "type": "text", "text": serde_json::to_string_pretty(&value).unwrap_or_default() }]
        }),
        touched_files,
    })
}

pub(super) async fn handle_ast_grep_rewrite(cg: &TokenSave, args: Value) -> Result<ToolResult> {
    let path = args
        .get("path")
        .and_then(|v| v.as_str())
        .ok_or_else(|| TokenSaveError::Config {
            message: "missing required parameter: path".to_string(),
        })?;

    let pattern = args
        .get("pattern")
        .and_then(|v| v.as_str())
        .ok_or_else(|| TokenSaveError::Config {
            message: "missing required parameter: pattern".to_string(),
        })?;

    let rewrite = args
        .get("rewrite")
        .and_then(|v| v.as_str())
        .ok_or_else(|| TokenSaveError::Config {
            message: "missing required parameter: rewrite".to_string(),
        })?;

    let root_override = project_root_arg(&args);
    let result = cg
        .ast_grep_rewrite(path, pattern, rewrite, root_override)
        .await?;
    let touched_files = if result.success {
        vec![result.file_path.clone()]
    } else {
        vec![]
    };
    Ok(ToolResult {
        value: json!({
            "content": [{ "type": "text", "text": serde_json::to_string_pretty(&result).unwrap_or_default() }]
        }),
        touched_files,
    })
}