Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.
Python agent-contextagent-memoryagent-pluginsagentic-ragcontext-databasedsh-pluginknowledge-basememorymemory-managementself-evolvingvector-database
use std::io::Write;
use std::path::PathBuf;
use serde_json::{Value, json};
use crate::SnapshotCmd;
use crate::client::{HttpClient, SnapshotCommitReq, SnapshotRestoreReq, SnapshotShowResult};
use crate::error::Result;
use crate::output::{OutputFormat, output_success};
pub async fn dispatch(
client: &HttpClient,
cmd: SnapshotCmd,
output_format: OutputFormat,
compact: bool,
) -> Result<()> {
match cmd {
SnapshotCmd::Commit {
message,
paths,
branch,
author_name,
author_email,
} => {
let req = SnapshotCommitReq {
message,
paths,
branch,
author_name,
author_email,
};
let value = client.snapshot_commit(&req).await?;
print_commit(&value, output_format, compact);
Ok(())
}
SnapshotCmd::Restore {
project_dir,
source_commit,
branch,
dry_run,
message,
author_name,
author_email,
} => {
let req = SnapshotRestoreReq {
project_dir,
source_commit,
branch,
dry_run,
message,
author_name,
author_email,
};
let value = client.snapshot_restore(&req).await?;
print_restore(&value, output_format, compact);
Ok(())
}
SnapshotCmd::Show {
target_ref,
path,
out_path,
} => {
let result = client.snapshot_show(&target_ref, path.as_deref()).await?;
handle_show(result, out_path, output_format, compact)
}
SnapshotCmd::Log {
branch,
limit,
paths,
} => {
let value = client
.snapshot_log(&branch, limit, paths.as_deref())
.await?;
print_log(&value, output_format, compact);
Ok(())
}
SnapshotCmd::Diff {
path,
from_ref,
to_ref,
} => {
let value = client
.snapshot_diff(&path, from_ref.as_deref(), &to_ref)
.await?;
print_diff(&value, output_format, compact);
Ok(())
}
SnapshotCmd::DiffPaths {
paths,
from_ref,
to_ref,
offset,
limit,
} => {
let value = client
.snapshot_diff_paths(&paths, from_ref.as_deref(), &to_ref, offset, limit)
.await?;
output_success(&value, output_format, compact);
Ok(())
}
SnapshotCmd::IgnoreGet => {
let value = client.snapshot_ignore_get().await?;
print_ignore_get(&value, output_format, compact);
Ok(())
}
SnapshotCmd::IgnoreSet { content, file } => {
let content = resolve_ignore_content(content.as_deref(), file.as_deref())?;
client.snapshot_ignore_set(&content).await?;
output_success(&json!({ "result": "set" }), output_format, compact);
Ok(())
}
SnapshotCmd::IgnoreDelete => {
client.snapshot_ignore_delete().await?;
output_success(&json!({ "result": "deleted" }), output_format, compact);
Ok(())
}
}
}
fn print_diff(value: &Value, output_format: OutputFormat, compact: bool) {
if matches!(output_format, OutputFormat::Json) {
output_success(value, output_format, compact);
return;
}
let diff = value.get("diff_text").and_then(Value::as_str).unwrap_or("");
let mut stdout = std::io::stdout();
let _ = stdout.write_all(diff.as_bytes());
let _ = stdout.flush();
}
/// Resolve `.ovgitignore` content: `--file` takes precedence over `--content`;
/// if neither is given, the content is left empty (clears the rules).
fn resolve_ignore_content(content: Option<&str>, file: Option<&std::path::Path>) -> Result<String> {
if let Some(path) = file {
use std::io::Read;
let mut buf = String::new();
std::fs::File::open(path)?.read_to_string(&mut buf)?;
return Ok(buf);
}
Ok(content.unwrap_or("").to_string())
}
fn print_ignore_get(value: &Value, output_format: OutputFormat, compact: bool) {
if matches!(output_format, OutputFormat::Json) {
output_success(value, output_format, compact);
return;
}
// Plain mode: print the raw content verbatim so it can be redirected to a file.
let content = value.as_str().unwrap_or("");
let mut stdout = std::io::stdout();
let _ = stdout.write_all(content.as_bytes());
let _ = stdout.flush();
}
fn print_commit(value: &Value, output_format: OutputFormat, compact: bool) {
if matches!(output_format, OutputFormat::Json) {
output_success(value, output_format, compact);
return;
}
// The server returns the inner result dict (BaseClient unwraps the envelope).
// It is already a flat object, so hand it to the shared table renderer.
output_success(value, OutputFormat::Table, compact);
}
fn print_restore(value: &Value, output_format: OutputFormat, compact: bool) {
if matches!(output_format, OutputFormat::Json) {
output_success(value, output_format, compact);
return;
}
// Dry-run shape nests counts under {diff: {to_write, to_delete, unchanged}},
// which the generic renderer cannot flatten. Reshape it into a flat dict;
// the applied/noop shapes are already flat and render directly.
let display = if let Some(diff) = value.get("diff") {
let count = |key: &str| {
diff.get(key)
.and_then(|v| v.as_array())
.map(|a| a.len())
.unwrap_or(0)
};
json!({
"result": "dry-run",
"to_write": count("to_write"),
"to_delete": count("to_delete"),
"unchanged": count("unchanged"),
})
} else {
value.clone()
};
output_success(&display, OutputFormat::Table, compact);
}
fn handle_show(
result: SnapshotShowResult,
out_path: Option<PathBuf>,
output_format: OutputFormat,
compact: bool,
) -> Result<()> {
match result {
SnapshotShowResult::Metadata(meta) => {
if matches!(output_format, OutputFormat::Json) {
output_success(&meta, output_format, compact);
return Ok(());
}
// Flatten the `parents` array into a scalar so the whole object
// renders as a single key/value table instead of the renderer
// collapsing onto just the list field.
let mut display = serde_json::Map::new();
for key in ["oid", "tree", "author", "committer"] {
if let Some(v) = meta.get(key) {
display.insert(key.to_string(), v.clone());
}
}
if let Some(parents) = meta.get("parents").and_then(|v| v.as_array()) {
let names: Vec<String> = parents
.iter()
.filter_map(|v| v.as_str().map(String::from))
.collect();
display.insert("parents".to_string(), Value::String(names.join(", ")));
}
if let Some(msg) = meta.get("message").and_then(|v| v.as_str()) {
display.insert("message".to_string(), Value::String(msg.to_string()));
}
output_success(&Value::Object(display), OutputFormat::Table, compact);
Ok(())
}
SnapshotShowResult::Blob { oid, bytes, size } => {
if matches!(output_format, OutputFormat::Json) {
let envelope = serde_json::json!({"oid": oid, "size": size});
if let Some(path) = out_path {
let mut f = std::fs::File::create(&path)?;
f.write_all(&bytes)?;
}
output_success(&envelope, output_format, compact);
return Ok(());
}
match out_path {
Some(path) => {
let mut f = std::fs::File::create(&path)?;
f.write_all(&bytes)?;
eprintln!(
"Wrote {} bytes from {} to {}",
size,
&oid[..12.min(oid.len())],
path.display()
);
}
None => {
let mut out = std::io::stdout().lock();
out.write_all(&bytes)?;
eprintln!("Read {} bytes from {}", size, &oid[..12.min(oid.len())]);
}
}
Ok(())
}
}
}
fn print_log(value: &Value, output_format: OutputFormat, compact: bool) {
if matches!(output_format, OutputFormat::Json) {
output_success(value, output_format, compact);
return;
}
// value is the unwrapped "result" — a JSON array of commit entries with
// nested authors and multi-line messages. Flatten each entry into a row so
// the shared renderer produces an aligned table like the other commands.
let entries = value.as_array().cloned().unwrap_or_default();
let rows: Vec<Value> = entries
.iter()
.map(|entry| {
let oid = entry.get("oid").and_then(|v| v.as_str()).unwrap_or("");
let short = oid.get(..12).unwrap_or(oid);
let msg_full = entry.get("message").and_then(|v| v.as_str()).unwrap_or("");
let subject = msg_full.lines().next().unwrap_or("");
let author = entry
.get("author")
.and_then(|a| a.get("name").or_else(|| a.as_str().map(|_| a)))
.and_then(|v| v.as_str())
.unwrap_or("");
json!({
"oid": short,
"author": author,
"subject": subject,
})
})
.collect();
output_success(&rows, OutputFormat::Table, compact);
}
#[cfg(test)]
mod tests {
use super::handle_show;
use crate::client::SnapshotShowResult;
use crate::output::OutputFormat;
#[test]
fn json_blob_show_writes_requested_output_file() {
let dir = tempfile::tempdir().expect("tempdir should be created");
let path = dir.path().join("blob.bin");
handle_show(
SnapshotShowResult::Blob {
oid: "abc123".to_string(),
bytes: b"snapshot-bytes".to_vec(),
size: 14,
},
Some(path.clone()),
OutputFormat::Json,
true,
)
.expect("blob output should be written");
assert_eq!(
std::fs::read(path).expect("blob output should be readable"),
b"snapshot-bytes"
);
}
#[test]
fn json_blob_show_propagates_output_file_errors() {
let dir = tempfile::tempdir().expect("tempdir should be created");
let result = handle_show(
SnapshotShowResult::Blob {
oid: "abc123".to_string(),
bytes: b"snapshot-bytes".to_vec(),
size: 14,
},
Some(dir.path().to_path_buf()),
OutputFormat::Json,
true,
);
assert!(result.is_err());
}
}