trusty-memory 0.1.45

Machine-wide, blazingly fast AI memory service
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
66

//! `dream` subcommand handler — background memory consolidation.
//!
//! Why: Surface the dream loop to operators: trigger a one-shot consolidation
//! pass, or inspect the current idle clock + dream config.
//! What: `Run` runs `Dreamer::dream_cycle` synchronously and prints
//! `DreamStats`; `Status` prints last-activity / is-idle / config.
//! Test: `dream::tests` cover behavior; CLI parse covered by
//! `cli_help_exits_zero`.

use crate::cli::memory::open_or_create_handle;
use crate::cli::output::OutputConfig;
use crate::cli::DreamCommands;
use anyhow::Result;
use serde_json::json;
use std::sync::Arc;
use trusty_memory_core::dream::{DreamConfig, Dreamer};

pub async fn handle(cmd: DreamCommands, palace: &str, out: &OutputConfig) -> Result<()> {
    match cmd {
        DreamCommands::Run => {
            out.print_header(palace, "dream/run");
            let handle = open_or_create_handle(palace).await?;
            let dreamer = Dreamer::new(DreamConfig::default());
            let stats = dreamer.dream_cycle(&handle).await?;
            if out.json {
                out.print_json(&json!({
                    "merged": stats.merged,
                    "pruned": stats.pruned,
                    "compacted": stats.compacted,
                    "closets_updated": stats.closets_updated,
                    "duration_ms": stats.duration_ms,
                }));
            } else {
                println!("merged:          {}", stats.merged);
                println!("pruned:          {}", stats.pruned);
                println!("compacted:       {}", stats.compacted);
                println!("closets_updated: {}", stats.closets_updated);
                println!("duration_ms:     {}", stats.duration_ms);
            }
        }
        DreamCommands::Status => {
            out.print_header(palace, "dream/status");
            let _handle: Arc<_> = open_or_create_handle(palace).await?;
            let dreamer = Dreamer::new(DreamConfig::default());
            let cfg = &dreamer.config;
            if out.json {
                out.print_json(&json!({
                    "is_idle": dreamer.is_idle(),
                    "config": {
                        "idle_secs": cfg.idle_secs,
                        "dedup_threshold": cfg.dedup_threshold,
                        "prune_importance": cfg.prune_importance,
                        "max_cycle_ms": cfg.max_cycle_ms,
                    }
                }));
            } else {
                println!("is_idle:           {}", dreamer.is_idle());
                println!("idle_secs:         {}", cfg.idle_secs);
                println!("dedup_threshold:   {}", cfg.dedup_threshold);
                println!("prune_importance:  {}", cfg.prune_importance);
                println!("max_cycle_ms:      {}", cfg.max_cycle_ms);
            }
        }
    }
    Ok(())
}