openmemory 0.1.1

//! OpenMemory Basic Usage Example
//!
//! Run:
//!   cargo run --example basic_usage
//!
//! With OpenAI:
//!   OPENAI_API_KEY=sk-xxx cargo run --example basic_usage

use openmemory::{
    core::types::Sector,
    AddOptions, EmbeddingKind, OpenMemory, OpenMemoryOptions, QueryOptions,
};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== OpenMemory Rust SDK Test ===\n");

    // 1. Create OpenMemory instance (in-memory DB + synthetic embeddings)
    println!("1. Initializing OpenMemory...");
    let om = OpenMemory::new(OpenMemoryOptions {
        db_path: ":memory:".into(), // In-memory DB (for file: "./test.db".into())
        embedding_kind: EmbeddingKind::Synthetic, // Local embeddings (no API required)
        vec_dim: Some(256),
        ..Default::default()
    })
    .await?;
    println!("   OK: Initialized\n");

    // 2. Add memories
    println!("2. Adding memories...");

    let memories = vec![
        ("I met a friend at the cafe yesterday.", vec!["daily", "friend"]),
        ("Python is an interpreted programming language.", vec!["programming", "knowledge"]),
        ("I learned how to git commit and push today.", vec!["git", "programming"]),
        ("The weather was great today, I felt happy.", vec!["emotion", "weather"]),
        ("I am building a habit of waking up at 7am every morning.", vec!["habit", "routine"]),
    ];

    for (content, tags) in memories {
        let result = om
            .add(
                content,
                AddOptions {
                    tags: Some(tags.iter().map(|s| s.to_string()).collect()),
                    ..Default::default()
                },
            )
            .await?;

        let preview: String = content.chars().take(30).collect();
        println!(
            "   OK: \"{}...\" -> sector: {:?}",
            preview,
            result.primary_sector
        );
    }
    println!();

    // 3. Query memories
    println!("3. Querying memories...\n");

    let queries = vec![
        "programming related memories",
        "what happened today",
        "feelings and emotions",
    ];

    for query in queries {
        println!("   Query: \"{}\"", query);

        let results = om
            .query(
                query,
                QueryOptions {
                    k: 3,
                    ..Default::default()
                },
            )
            .await?;

        if results.is_empty() {
            println!("   No results\n");
        } else {
            for (i, result) in results.iter().enumerate() {
                let content_preview: String = result.content.chars().take(40).collect();
                println!(
                    "   {}. [score: {:.3}] [sector: {:?}] {}",
                    i + 1,
                    result.score,
                    result.primary_sector,
                    content_preview
                );
            }
            println!();
        }
    }

    // 4. Query by sector
    println!("4. Query by sector (Semantic only)...");
    let semantic_results = om
        .query(
            "knowledge",
            QueryOptions {
                k: 5,
                sectors: Some(vec![Sector::Semantic]),
                ..Default::default()
            },
        )
        .await?;

    for result in &semantic_results {
        println!("   - {:?}: {}", result.primary_sector, result.content);
    }
    println!();

    // 5. Run memory decay
    println!("5. Running memory decay...");
    let decay_stats = om.run_decay().await?;
    println!(
        "   OK: processed: {}, decayed: {}, duration: {}ms\n",
        decay_stats.processed, decay_stats.decayed, decay_stats.duration_ms
    );

    // 6. List all memories
    println!("6. All memories:");
    let all = om.get_all(100, 0).await?;
    for mem in &all {
        println!(
            "   - [{}] salience: {:.2}, sector: {:?}",
            &mem.id[..8],
            mem.salience,
            mem.primary_sector
        );
    }

    println!("\n=== Test Complete ===");
    Ok(())
}