remem-ai 0.6.17

Local-first coding agent memory for Claude Code and OpenAI Codex
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

use super::types::{Cli, Commands, RuleActionArg, RuleHostArg, RulesAction};
use clap::Parser;

#[test]
fn cli_parses_compiled_rule_management_commands() {
    let list = Cli::parse_from(["remem", "rules", "list", "--project", "/tmp/remem"]);
    match list.command {
        Commands::Rules {
            action: RulesAction::List { project },
        } => assert_eq!(project.as_deref(), Some("/tmp/remem")),
        _ => panic!("expected rules list command"),
    }

    let disable = Cli::parse_from(["remem", "rules", "disable", "pref-1-1"]);
    assert!(matches!(
        disable.command,
        Commands::Rules {
            action: RulesAction::Disable { rule_id }
        } if rule_id == "pref-1-1"
    ));

    let enable = Cli::parse_from(["remem", "rules", "enable", "pref-1-1"]);
    assert!(matches!(
        enable.command,
        Commands::Rules {
            action: RulesAction::Enable { rule_id }
        } if rule_id == "pref-1-1"
    ));

    for action_name in ["warn", "block"] {
        let set_action = Cli::parse_from(["remem", "rules", "set-action", "pref-1-1", action_name]);
        assert!(matches!(
            set_action.command,
            Commands::Rules {
                action: RulesAction::SetAction {
                    rule_id,
                    action: RuleActionArg::Warn | RuleActionArg::Block,
                    host: None,
                }
            } if rule_id == "pref-1-1"
        ));
    }

    let block = Cli::parse_from([
        "remem",
        "rules",
        "set-action",
        "pref-1-1",
        "block",
        "--host",
        "claude-code",
    ]);
    assert!(matches!(
        block.command,
        Commands::Rules {
            action: RulesAction::SetAction {
                action: RuleActionArg::Block,
                host: Some(RuleHostArg::ClaudeCode),
                ..
            }
        }
    ));

    let eval = Cli::parse_from(["remem", "rules", "eval", "--host", "claude-code"]);
    assert!(matches!(
        eval.command,
        Commands::Rules {
            action: RulesAction::Eval {
                host: Some(RuleHostArg::ClaudeCode)
            }
        }
    ));
}