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 crate::client::HttpClient;
use crate::error::Result;
use crate::output::OutputFormat;
use serde_json::{Value, json};
use std::collections::BTreeSet;
use std::io::Write;
use std::path::Path;
/// Print the requested line range; propagate request and output errors to the CLI.
pub async fn read(
client: &HttpClient,
uri: &str,
offset: i64,
limit: i64,
output_format: OutputFormat,
compact: bool,
) -> Result<()> {
let content = client.read_profiled(uri, offset, limit).await?;
output_content_result(content, output_format, compact)
}
pub async fn abstract_content(
client: &HttpClient,
uri: &str,
output_format: OutputFormat,
compact: bool,
) -> Result<()> {
let content = client.abstract_content_profiled(uri).await?;
output_content_result(content, output_format, compact)
}
pub async fn overview(
client: &HttpClient,
uri: &str,
output_format: OutputFormat,
compact: bool,
) -> Result<()> {
let content = client.overview_profiled(uri).await?;
output_content_result(content, output_format, compact)
}
pub async fn write(
client: &HttpClient,
uri: &str,
content: &str,
mode: &str,
wait: bool,
processing_mode: &str,
tags: Vec<String>,
tag_mode: &str,
acl: Option<serde_json::Value>,
edit_source: &str,
output_format: OutputFormat,
compact: bool,
) -> Result<()> {
let result = client
.write(
uri,
content,
mode,
wait,
processing_mode,
tags,
tag_mode,
acl,
edit_source,
)
.await?;
crate::output::output_success(result, output_format, compact);
Ok(())
}
pub async fn set_tags(
client: &HttpClient,
uri: &str,
tags: Vec<String>,
mode: &str,
recursive: bool,
output_format: OutputFormat,
compact: bool,
) -> Result<()> {
// Tags are explicit k=v metadata labels; append mode replaces any existing value for the same key.
let result = client.set_tags(uri, tags, mode, recursive).await?;
output_set_tags_result(result, output_format, compact);
Ok(())
}
pub async fn reindex(
client: &HttpClient,
uri: &str,
mode: &str,
wait: bool,
force: bool,
tags: Vec<String>,
tag_mode: &str,
recursive: bool,
output_format: OutputFormat,
compact: bool,
) -> Result<()> {
let result = client
.reindex(uri, mode, wait, force, tags, tag_mode, recursive)
.await?;
crate::output::output_success(result, output_format, compact);
Ok(())
}
pub async fn get(client: &HttpClient, uri: &str, local_path: &str) -> Result<()> {
// Check if target path already exists
let path = Path::new(local_path);
if path.exists() {
return Err(crate::error::Error::Client(format!(
"File already exists: {}",
local_path
)));
}
// Ensure parent directory exists
if let Some(parent) = path.parent() {
std::fs::create_dir_all(parent)?;
}
// Download file
let bytes = client.get_bytes(uri).await?;
// Write to local file
let mut file = create_download_target(path, local_path)?;
file.write_all(&bytes)?;
file.flush()?;
println!("Downloaded {} bytes to {}", bytes.len(), local_path);
Ok(())
}
fn create_download_target(path: &Path, local_path: &str) -> Result<std::fs::File> {
std::fs::OpenOptions::new()
.write(true)
.create_new(true)
.open(path)
.map_err(|error| {
if error.kind() == std::io::ErrorKind::AlreadyExists {
crate::error::Error::Client(format!("File already exists: {local_path}"))
} else {
crate::error::Error::Io(error)
}
})
}
fn output_content_result(result: Value, output_format: OutputFormat, compact: bool) -> Result<()> {
match output_format {
OutputFormat::Json => crate::output::output_success(result, output_format, compact),
OutputFormat::Table => {
if let Some(rendered) = crate::output::render_profiled_scalar_result(&result) {
println!("{}", rendered);
} else if let Some(content) = result.as_str() {
println!("{}", content);
} else {
crate::output::output_success(result, output_format, compact);
}
}
}
Ok(())
}
fn output_set_tags_result(result: Value, output_format: OutputFormat, compact: bool) {
match output_format {
OutputFormat::Json => crate::output::output_success(result, output_format, compact),
OutputFormat::Table => {
if let Some(rendered) = render_set_tags_result_for_table(&result) {
println!("{rendered}");
} else {
crate::output::output_success(result, output_format, compact);
}
}
}
}
fn render_set_tags_result_for_table(result: &Value) -> Option<String> {
let obj = result.as_object()?;
let uri = obj.get("uri")?.as_str()?;
let tags = obj
.get("tags")
.and_then(Value::as_array)
.map(|items| {
items
.iter()
.filter_map(Value::as_str)
.collect::<Vec<_>>()
.join(", ")
})
.unwrap_or_default();
let updated_uris = obj
.get("updated_uris")
.and_then(Value::as_array)
.map(|items| {
let unique = items
.iter()
.filter_map(Value::as_str)
.collect::<BTreeSet<_>>();
let count = unique.len();
if count == 0 {
String::new()
} else if count == 1 {
unique.into_iter().next().unwrap_or_default().to_string()
} else {
let lines = unique
.into_iter()
.map(|item| format!("- {item}"))
.collect::<Vec<_>>()
.join("\n");
format!("{count} updates\n{lines}")
}
})
.unwrap_or_default();
let display = json!({
"uri": uri,
"tags": tags,
"updated_uris": updated_uris,
"mode": obj.get("mode").cloned().unwrap_or(Value::Null),
"success_count": obj.get("success_count").cloned().unwrap_or(Value::Null),
"skipped_count": obj.get("skipped_count").cloned().unwrap_or(Value::Null),
"failed_count": obj.get("failed_count").cloned().unwrap_or(Value::Null),
"tags_updated": obj.get("tags_updated").cloned().unwrap_or(Value::Null),
});
crate::output::render_table_with_optional_profile(&display, true)
}
#[cfg(test)]
mod tests {
use crate::error::Error;
use serde_json::json;
fn strip_ansi(input: &str) -> String {
let mut output = String::with_capacity(input.len());
let mut chars = input.chars().peekable();
while let Some(ch) = chars.next() {
if ch == '\u{1b}' && chars.peek() == Some(&'[') {
chars.next();
for next in chars.by_ref() {
if next.is_ascii_alphabetic() {
break;
}
}
continue;
}
output.push(ch);
}
output
}
#[test]
fn table_output_renders_profiled_scalar_content() {
let result = json!({
"result": "content",
"profile": [
"line one",
"line two"
]
});
let rendered = crate::output::render_profiled_scalar_result(&result);
assert_eq!(
rendered,
Some(["content", "", "profile", "line one", "line two", "",].join("\n"))
);
}
#[test]
fn table_output_renders_set_tags_uri_and_updated_uris() {
let result = json!({
"uri": "viking://resources/demo/doc.md",
"updated_uris": [
"viking://resources/demo/doc.md",
"viking://resources/demo/doc.md",
"viking://resources/demo/doc.md/doc_v2.md"
],
"tags": ["team=test"],
"mode": "replace",
"success_count": 3,
"skipped_count": 0,
"failed_count": 0,
"tags_updated": true
});
let rendered =
super::render_set_tags_result_for_table(&result).map(|value| strip_ansi(&value));
assert_eq!(
rendered,
Some(
[
"uri viking://resources/demo/doc.md",
"tags team=test",
"updated_uris 2 updates",
"- viking://resources/demo/doc.md",
"- viking://resources/demo/doc.md/doc_v2.md",
"mode replace",
"success_count 3",
"skipped_count 0",
"failed_count 0",
"tags_updated true",
]
.join("\n")
+ "\n"
)
);
}
#[test]
fn download_target_creation_does_not_truncate_an_existing_file() {
let dir = tempfile::tempdir().expect("tempdir should be created");
let path = dir.path().join("result.bin");
std::fs::write(&path, b"existing").expect("fixture should be written");
let error = super::create_download_target(&path, &path.to_string_lossy())
.expect_err("existing targets must be rejected atomically");
assert!(matches!(error, Error::Client(_)));
assert_eq!(
std::fs::read(&path).expect("existing file should remain readable"),
b"existing"
);
}
}