remem-ai 0.6.42

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

use std::path::Path;

use anyhow::Result;

use super::super::archive_types::ExportArgs;
use super::markdown_archive::run_export_markdown;
use super::pack_export::run_export_pack;

pub(in crate::cli) fn run_export(args: ExportArgs, project: &str) -> Result<()> {
    if args.markdown {
        if args.pack.is_some() {
            anyhow::bail!("export accepts either --markdown or --pack, not both");
        }
        let Some(output) = args.output.as_deref() else {
            anyhow::bail!("markdown export requires --output <dir>");
        };
        return run_export_markdown(true, output, project, args.include_inactive, args.limit);
    }

    if args.output.is_some() {
        anyhow::bail!("pack export uses --pack <dir>; --output is only valid with --markdown");
    }
    if args.include_inactive {
        anyhow::bail!("pack export only includes active startup memories; --include-inactive is only valid with --markdown");
    }
    let pack_dir = args.pack.as_deref().unwrap_or(Path::new(".remem-pack"));
    run_export_pack(pack_dir, project, args.limit)?;
    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::path::PathBuf;

    #[test]
    fn export_rejects_markdown_and_pack_together() {
        let error = run_export(
            ExportArgs {
                markdown: true,
                output: Some(PathBuf::from("/tmp/remem-md")),
                pack: Some(PathBuf::from("/tmp/remem-pack")),
                project: None,
                include_inactive: false,
                limit: 100,
            },
            "/repo",
        )
        .expect_err("markdown and pack are mutually exclusive");

        assert!(
            error
                .to_string()
                .contains("either --markdown or --pack, not both"),
            "{error:?}"
        );
    }

    #[test]
    fn export_rejects_pack_with_markdown_only_flags() {
        let error = run_export(
            ExportArgs {
                markdown: false,
                output: Some(PathBuf::from("/tmp/remem-md")),
                pack: None,
                project: None,
                include_inactive: false,
                limit: 100,
            },
            "/repo",
        )
        .expect_err("pack export should not ignore --output");

        assert!(
            error
                .to_string()
                .contains("--output is only valid with --markdown"),
            "{error:?}"
        );
    }
}