mati 0.1.2

An enforcement layer for codebase knowledge: confirmed gotchas gate what AI agents read and edit at the hook level. Not a passive memory store.
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

//! CLI config subcommand for enforcement settings.
//!
//! ```text
//! mati config get audit.write_durability
//! mati config set audit.write_durability strict
//! mati config get enforcement.retention
//! mati config set enforcement.retention 365
//! ```

use anyhow::Result;
use clap::{Args, Subcommand};

use super::proxy::StoreProxy;

#[derive(Args)]
pub struct ConfigArgs {
    #[command(subcommand)]
    pub command: ConfigCommand,
}

/// All known config keys (mirrors the set validated in `proxy::config_get`).
const CONFIG_KEYS: &[&str] = &["audit.write_durability", "enforcement.retention"];

#[derive(Subcommand)]
pub enum ConfigCommand {
    /// Get a configuration value
    Get {
        /// Configuration key (e.g., audit.write_durability, enforcement.retention)
        key: String,
    },
    /// Set a configuration value
    Set {
        /// Configuration key (e.g., audit.write_durability, enforcement.retention)
        key: String,
        /// Value to set
        value: String,
    },
    /// Show all resolved configuration values
    Dump,
}

pub async fn run(args: ConfigArgs) -> Result<()> {
    let cwd = std::env::current_dir()?;
    let proxy = StoreProxy::open(&cwd).await?;

    let result = match args.command {
        ConfigCommand::Get { ref key } => run_get(&proxy, key).await,
        ConfigCommand::Set { ref key, ref value } => run_set(&proxy, key, value).await,
        ConfigCommand::Dump => run_dump(&proxy).await,
    };

    proxy.close().await?;
    result
}

async fn run_get(proxy: &StoreProxy, key: &str) -> Result<()> {
    let value = proxy.config_get(key).await?;
    println!("{value}");
    Ok(())
}

/// Print every known config key with its resolved value.
async fn run_dump(proxy: &StoreProxy) -> Result<()> {
    for key in CONFIG_KEYS {
        match proxy.config_get(key).await {
            Ok(value) => println!("{key} = {value}"),
            Err(e) => println!("{key} = <unavailable: {e}>"),
        }
    }
    Ok(())
}

async fn run_set(proxy: &StoreProxy, key: &str, value: &str) -> Result<()> {
    let old = proxy.config_set(key, value).await?;
    match key {
        "audit.write_durability" => {
            if old == value {
                println!("audit.write_durability is already {value}");
            } else if old.is_empty() {
                println!("audit.write_durability: {value}");
            } else {
                println!("audit.write_durability: {old} → {value}");
            }
        }
        "enforcement.retention" => {
            println!("enforcement.retention: {value} days");
        }
        _ => {}
    }
    Ok(())
}