edda 0.2.1

Decision memory for coding agents — CLI and TUI
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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

//! CLI subcommand: `edda rules` — manage learned rules from L3 post-mortem.

use clap::Subcommand;
use std::path::Path;

#[derive(Subcommand)]
pub enum RulesCmd {
    /// List all rules (default: alive only)
    List {
        /// Show all rules including dead/superseded
        #[arg(long)]
        all: bool,
        /// Output as JSON
        #[arg(long)]
        json: bool,
    },
    /// Show a specific rule by ID
    Show {
        /// Rule ID (rule_*)
        id: String,
    },
    /// Run decay cycle on all rules
    Decay,
    /// Show rules store statistics
    Stats,
    /// Garbage-collect dead rules
    Gc,
}

pub fn execute(cmd: RulesCmd, repo_root: &Path) -> anyhow::Result<()> {
    let project_id = edda_store::project_id(repo_root);

    match cmd {
        RulesCmd::List { all, json } => {
            let store = edda_postmortem::RulesStore::load_project(&project_id);
            let rules: Vec<_> = if all {
                store.rules.iter().collect()
            } else {
                store.alive_rules()
            };

            if rules.is_empty() {
                if !json {
                    println!("No rules found.");
                }
                return Ok(());
            }

            if json {
                for rule in &rules {
                    println!("{}", serde_json::to_string(rule)?);
                }
            } else {
                println!(
                    "{:<12} {:<10} {:<12} {:<5} TRIGGER → ACTION",
                    "STATUS", "CATEGORY", "HITS", "TTL"
                );
                println!("{}", "-".repeat(70));
                for rule in &rules {
                    println!(
                        "{:<12} {:<10} {:<12} {:<5} {} → {}",
                        rule.status,
                        rule.category,
                        rule.hits,
                        rule.ttl_days,
                        rule.trigger,
                        rule.action,
                    );
                }
                println!("\n{} rules shown.", rules.len());
            }
        }

        RulesCmd::Show { id } => {
            let store = edda_postmortem::RulesStore::load_project(&project_id);
            match store.get(&id) {
                Some(rule) => {
                    println!("{}", serde_json::to_string_pretty(rule)?);
                }
                None => {
                    anyhow::bail!("Rule not found: {id}");
                }
            }
        }

        RulesCmd::Decay => {
            let mut store = edda_postmortem::RulesStore::load_project(&project_id);
            let before = store.stats();
            store.run_decay_cycle();
            let after = store.stats();
            store.save_project(&project_id)?;
            println!("Decay cycle complete.");
            println!("  Active: {} → {}", before.active, after.active);
            println!("  Dormant: {} → {}", before.dormant, after.dormant);
            println!("  Dead: {} → {}", before.dead, after.dead);
        }

        RulesCmd::Stats => {
            let store = edda_postmortem::RulesStore::load_project(&project_id);
            let stats = store.stats();
            println!("Rules store statistics:");
            println!("  Total:      {}", stats.total);
            println!("  Proposed:   {}", stats.proposed);
            println!("  Active:     {}", stats.active);
            println!("  Dormant:    {}", stats.dormant);
            println!("  Settled:    {}", stats.settled);
            println!("  Dead:       {}", stats.dead);
            println!("  Superseded: {}", stats.superseded);
            if let Some(ref last) = store.last_decay_run {
                println!("  Last decay: {}", last);
            }
        }

        RulesCmd::Gc => {
            let mut store = edda_postmortem::RulesStore::load_project(&project_id);
            let removed = store.gc_dead_rules();
            store.save_project(&project_id)?;
            println!("Removed {removed} dead rules.");
        }
    }

    Ok(())
}