eddacraft-kindling 0.3.0

Local-first memory and continuity CLI for AI-assisted development (the `kindling` binary).
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
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

//! `status` — database statistics plus capability handshake. In-process only.
//!
//! The `--json` shape augments the prior `{ database, counts, activity }` layout
//! with the capability block (`version`, `schemaVersion`, `supportedKinds`,
//! `storagePath`, `kindRegistry`).

use kindling_types::build_capability;
use serde::Serialize;

use crate::cli::StatusArgs;
use crate::output::{format_json, iso8601_utc};
use crate::{open_service, CliResult};

#[derive(Serialize)]
struct StatusOutput {
    #[serde(flatten)]
    capability: kindling_types::Capability,
    database: DatabaseSection,
    counts: CountsSection,
    activity: ActivitySection,
}

#[derive(Serialize)]
struct DatabaseSection {
    path: String,
    size: String,
    #[serde(rename = "sizeBytes")]
    size_bytes: i64,
}

#[derive(Serialize)]
struct CountsSection {
    observations: i64,
    capsules: i64,
    summaries: i64,
    pins: i64,
    redacted: i64,
    #[serde(rename = "openCapsules")]
    open_capsules: i64,
}

#[derive(Serialize)]
struct ActivitySection {
    #[serde(rename = "latestTimestamp")]
    latest_timestamp: Option<i64>,
    #[serde(rename = "latestDate")]
    latest_date: Option<String>,
}

pub fn run(args: StatusArgs) -> CliResult {
    let (service, db_path) = open_service(args.common.db.as_deref())?;
    let stats = service.store().database_stats()?;

    // `(bytes / 1MiB).toFixed(2)` — matches the TS size string.
    let size_mb = stats.size_bytes as f64 / (1024.0 * 1024.0);
    let size = format!("{size_mb:.2} MB");

    let latest_date = stats.latest_ts.map(iso8601_utc);

    let capability = build_capability(
        env!("CARGO_PKG_VERSION"),
        kindling_store::schema_version().version as u32,
        db_path.to_string_lossy(),
    );

    let output = StatusOutput {
        capability,
        database: DatabaseSection {
            path: db_path.to_string_lossy().into_owned(),
            size: size.clone(),
            size_bytes: stats.size_bytes,
        },
        counts: CountsSection {
            observations: stats.observations,
            capsules: stats.capsules,
            summaries: stats.summaries,
            pins: stats.pins,
            redacted: stats.redacted,
            open_capsules: stats.open_capsules,
        },
        activity: ActivitySection {
            latest_timestamp: stats.latest_ts,
            latest_date: latest_date.clone(),
        },
    };

    if args.common.json {
        println!("{}", format_json(&output, true)?);
    } else {
        println!("\nKindling Database Status");
        println!("========================\n");
        println!("Database: {}", output.database.path);
        println!("Size:     {size}\n");
        println!("Entity Counts:");
        println!("  Observations: {}", output.counts.observations);
        println!("  Capsules:     {}", output.counts.capsules);
        println!("  Summaries:    {}", output.counts.summaries);
        println!("  Pins:         {}", output.counts.pins);
        println!("  Redacted:     {}", output.counts.redacted);
        println!("  Open Capsules: {}\n", output.counts.open_capsules);
        println!("Latest Activity:");
        println!(
            "  {}\n",
            latest_date.unwrap_or_else(|| "No activity yet".to_string())
        );
    }
    Ok(())
}