remem-ai 0.6.36

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
74
75
76
77
78
79
80
81
82
83
84
85

use clap::Parser;

use super::types::{Cli, Commands, PendingAction};

#[test]
fn pending_archived_range_requires_dual_exact_dry_run() {
    let valid = Cli::parse_from([
        "remem",
        "pending",
        "retry-extraction-ranges",
        "--id",
        "308",
        "--acknowledge-quarantine",
        "--include-archived",
        "--dry-run",
    ]);
    match valid.command {
        Commands::Pending {
            action:
                PendingAction::RetryExtractionRanges {
                    id,
                    acknowledge_quarantine,
                    include_archived,
                    dry_run,
                    ..
                },
        } => {
            assert_eq!(id, Some(308));
            assert!(acknowledge_quarantine);
            assert!(include_archived);
            assert!(dry_run);
        }
        _ => panic!("expected archived exact dry-run"),
    }

    for invalid in [
        vec!["--include-archived"],
        vec!["--id", "308", "--include-archived", "--dry-run"],
        vec![
            "--id",
            "308",
            "--acknowledge-quarantine",
            "--include-archived",
        ],
    ] {
        let mut args = vec!["remem", "pending", "retry-extraction-ranges"];
        args.extend(invalid);
        assert!(Cli::try_parse_from(args).is_err());
    }
}

#[test]
fn worker_exact_replay_requires_complete_argument_set() {
    let cli = Cli::parse_from([
        "remem",
        "worker",
        "--once",
        "--replay-range-id",
        "308",
        "--acknowledge-quarantine",
        "--include-archived",
        "--profile",
        "claude",
    ]);
    match cli.command {
        Commands::Worker(args) => {
            assert!(args.once);
            assert_eq!(args.replay_range_id, Some(308));
            assert!(args.acknowledge_quarantine);
            assert!(args.include_archived);
            assert_eq!(args.profile.as_deref(), Some("claude"));
        }
        _ => panic!("expected exact worker command"),
    }

    for incomplete in [
        vec!["--replay-range-id", "308"],
        vec!["--once", "--replay-range-id", "308", "--profile", "claude"],
        vec!["--once", "--profile", "claude"],
    ] {
        let mut args = vec!["remem", "worker"];
        args.extend(incomplete);
        assert!(Cli::try_parse_from(args).is_err());
    }
}