chaotic_semantic_memory 0.3.4

AI memory systems with hyperdimensional vectors and chaotic reservoirs
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

use std::path::Path;

use tracing::instrument;

use crate::cli::args::{ExportArgs, ExportFormat, OutputFormat};
use crate::cli::error::{CliError, Result};

use super::{create_framework, print_success, print_warning};

#[instrument(name = "cli_export")]
pub async fn run_export(
    args: ExportArgs,
    db_path: Option<&Path>,
    format: OutputFormat,
) -> Result<()> {
    let framework = create_framework(db_path).await?;

    let path_str = args.output.to_string_lossy();
    let stats = framework
        .stats()
        .await
        .map_err(|e| CliError::Persistence(format!("failed to get stats: {e}")))?;

    if stats.concept_count == 0 {
        print_warning("exporting empty memory state", format);
    } else if matches!(format, OutputFormat::Table) {
        eprintln!(
            "Exporting {} concepts to {}...",
            stats.concept_count,
            args.output.display()
        );
    }

    let result = match args.format {
        ExportFormat::Json => framework.export_json(&path_str).await,
        ExportFormat::Binary => framework.export_binary(&path_str).await,
    };

    match result {
        Ok(()) => {
            print_success(
                &format!(
                    "exported {} concepts to {}",
                    stats.concept_count,
                    args.output.display()
                ),
                format,
            );
            if matches!(format, OutputFormat::Json) {
                println!(
                    "{}",
                    serde_json::json!({
                        "exported": stats.concept_count,
                        "path": args.output.display().to_string()
                    })
                );
            }
        }
        Err(e) => {
            return Err(CliError::Output(format!("export failed: {e}")));
        }
    }

    Ok(())
}