sqlite_graphrag/commands/
rename.rs

1use crate::errors::AppError;
2use crate::i18n::erros;
3use crate::output;
4use crate::output::JsonOutputFormat;
5use crate::paths::AppPaths;
6use crate::storage::connection::open_rw;
7use crate::storage::{memories, versions};
8use serde::Serialize;
9
10#[derive(clap::Args)]
11pub struct RenameArgs {
12    /// Current memory name. Also accepts the alias `--old`.
13    #[arg(long, alias = "old")]
14    pub name: String,
15    /// New memory name. Also accepts the alias `--new`.
16    #[arg(long, alias = "new")]
17    pub new_name: String,
18    #[arg(long, default_value = "global")]
19    pub namespace: Option<String>,
20    /// Optimistic locking: rejeitar se updated_at atual não bater (exit 3).
21    #[arg(
22        long,
23        value_name = "EPOCH_OR_RFC3339",
24        value_parser = crate::parsers::parse_expected_updated_at,
25        long_help = "Optimistic lock: reject if updated_at does not match. \
26Accepts Unix epoch (e.g. 1700000000) or RFC 3339 (e.g. 2026-04-19T12:00:00Z)."
27    )]
28    pub expected_updated_at: Option<i64>,
29    /// Optional session ID used to trace the origin of the change.
30    #[arg(long, value_name = "UUID")]
31    pub session_id: Option<String>,
32    /// Output format.
33    #[arg(long, value_enum, default_value_t = JsonOutputFormat::Json)]
34    pub format: JsonOutputFormat,
35    #[arg(long, help = "No-op; JSON is always emitted on stdout")]
36    pub json: bool,
37    #[arg(long, env = "SQLITE_GRAPHRAG_DB_PATH")]
38    pub db: Option<String>,
39}
40
41#[derive(Serialize)]
42struct RenameResponse {
43    memory_id: i64,
44    name: String,
45    action: &'static str,
46    version: i64,
47    /// Tempo total de execução em milissegundos desde início do handler até serialização.
48    elapsed_ms: u64,
49}
50
51pub fn run(args: RenameArgs) -> Result<(), AppError> {
52    let inicio = std::time::Instant::now();
53    let _ = args.format;
54    use crate::constants::*;
55
56    let namespace = crate::namespace::resolve_namespace(args.namespace.as_deref())?;
57
58    let normalized_new_name = {
59        let n = args.new_name.to_lowercase().replace(['_', ' '], "-");
60        if n != args.new_name {
61            tracing::warn!(
62                original = %args.new_name,
63                normalized = %n,
64                "new_name auto-normalized to kebab-case"
65            );
66        }
67        n
68    };
69
70    if normalized_new_name.starts_with("__") {
71        return Err(AppError::Validation(
72            crate::i18n::validacao::nome_reservado(),
73        ));
74    }
75
76    if normalized_new_name.is_empty() || normalized_new_name.len() > MAX_MEMORY_NAME_LEN {
77        return Err(AppError::Validation(
78            crate::i18n::validacao::novo_nome_comprimento(MAX_MEMORY_NAME_LEN),
79        ));
80    }
81
82    {
83        let slug_re = regex::Regex::new(crate::constants::NAME_SLUG_REGEX)
84            .map_err(|e| AppError::Internal(anyhow::anyhow!("regex: {e}")))?;
85        if !slug_re.is_match(&normalized_new_name) {
86            return Err(AppError::Validation(
87                crate::i18n::validacao::novo_nome_kebab(&normalized_new_name),
88            ));
89        }
90    }
91
92    let paths = AppPaths::resolve(args.db.as_deref())?;
93    let mut conn = open_rw(&paths.db)?;
94
95    let (memory_id, current_updated_at, _) = memories::find_by_name(&conn, &namespace, &args.name)?
96        .ok_or_else(|| AppError::NotFound(erros::memoria_nao_encontrada(&args.name, &namespace)))?;
97
98    if let Some(expected) = args.expected_updated_at {
99        if expected != current_updated_at {
100            return Err(AppError::Conflict(erros::conflito_optimistic_lock(
101                expected,
102                current_updated_at,
103            )));
104        }
105    }
106
107    let row = memories::read_by_name(&conn, &namespace, &args.name)?
108        .ok_or_else(|| AppError::Internal(anyhow::anyhow!("memory not found before rename")))?;
109
110    let memory_type = row.memory_type.clone();
111    let description = row.description.clone();
112    let body = row.body.clone();
113    let metadata = row.metadata.clone();
114
115    let tx = conn.transaction_with_behavior(rusqlite::TransactionBehavior::Immediate)?;
116
117    let affected = if let Some(ts) = args.expected_updated_at {
118        tx.execute(
119            "UPDATE memories SET name=?2 WHERE id=?1 AND updated_at=?3 AND deleted_at IS NULL",
120            rusqlite::params![memory_id, normalized_new_name, ts],
121        )?
122    } else {
123        tx.execute(
124            "UPDATE memories SET name=?2 WHERE id=?1 AND deleted_at IS NULL",
125            rusqlite::params![memory_id, normalized_new_name],
126        )?
127    };
128
129    if affected == 0 {
130        return Err(AppError::Conflict(
131            "optimistic lock conflict: memory was modified by another process".to_string(),
132        ));
133    }
134
135    let next_v = versions::next_version(&tx, memory_id)?;
136
137    versions::insert_version(
138        &tx,
139        memory_id,
140        next_v,
141        &normalized_new_name,
142        &memory_type,
143        &description,
144        &body,
145        &metadata,
146        None,
147        "rename",
148    )?;
149
150    tx.commit()?;
151
152    output::emit_json(&RenameResponse {
153        memory_id,
154        name: normalized_new_name,
155        action: "renamed",
156        version: next_v,
157        elapsed_ms: inicio.elapsed().as_millis() as u64,
158    })?;
159
160    Ok(())
161}
162
163#[cfg(test)]
164mod testes {
165    use crate::storage::memories::{insert, NewMemory};
166    use tempfile::TempDir;
167
168    fn setup_db() -> (TempDir, rusqlite::Connection) {
169        crate::storage::connection::register_vec_extension();
170        let dir = TempDir::new().unwrap();
171        let db_path = dir.path().join("test.db");
172        let mut conn = rusqlite::Connection::open(&db_path).unwrap();
173        crate::migrations::runner().run(&mut conn).unwrap();
174        (dir, conn)
175    }
176
177    fn nova_memoria(name: &str) -> NewMemory {
178        NewMemory {
179            namespace: "global".to_string(),
180            name: name.to_string(),
181            memory_type: "user".to_string(),
182            description: "desc".to_string(),
183            body: "corpo".to_string(),
184            body_hash: format!("hash-{name}"),
185            session_id: None,
186            source: "agent".to_string(),
187            metadata: serde_json::json!({}),
188        }
189    }
190
191    #[test]
192    fn rejeita_new_name_com_prefixo_duplo_underscore() {
193        use crate::errors::AppError;
194        let (_dir, conn) = setup_db();
195        insert(&conn, &nova_memoria("mem-teste")).unwrap();
196        drop(conn);
197
198        let err = AppError::Validation(
199            "names and namespaces starting with __ are reserved for internal use".to_string(),
200        );
201        assert!(err.to_string().contains("__"));
202        assert_eq!(err.exit_code(), 1);
203    }
204
205    #[test]
206    fn optimistic_lock_conflict_retorna_exit_3() {
207        use crate::errors::AppError;
208        let err = AppError::Conflict(
209            "optimistic lock conflict: expected updated_at=100, but current is 200".to_string(),
210        );
211        assert_eq!(err.exit_code(), 3);
212    }
213}
sqlite_graphrag/commands/rename.rs

sqlite_graphrag/commands/
rename.rs
