clipmem 0.4.3

macOS clipboard memory backed by SQLite and searchable from agent runtimes
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
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
124
125
126
127
128
129
130
131
132
133

use clap::error::ErrorKind;

use super::errors::{clap_error, clap_error_from_value, CliValueError};
use super::schema::{
    Cli, Command, OcrCommand, ServiceCommand, SettingsCommand, SettingsIgnoreCommand,
    StorageCommand, StorageOptimizeImagesArgs,
};

fn validate_value<T>(
    result: std::result::Result<T, CliValueError>,
) -> std::result::Result<T, clap::Error> {
    result.map_err(clap_error_from_value)
}

pub(super) fn validate_cli(cli: &Cli) -> std::result::Result<(), clap::Error> {
    match &cli.command {
        Command::Agents(_args) => {}
        Command::Setup(_) => {}
        Command::Service(args) => {
            if let ServiceCommand::Status(args) = &args.command {
                validate_json_human_flags(args.json, args.human)?;
            }
        }
        Command::Search(args) => {
            validate_value(args.output.resolved())?;
            validate_value(args.filters.normalized())?;
        }
        Command::Recent(args) => {
            validate_value(args.output.resolved())?;
            validate_value(args.filters.normalized())?;
        }
        Command::Timeline(args) => {
            validate_value(args.output.resolved())?;
            validate_value(args.filters.normalized())?;
        }
        Command::Stats(args) => {
            validate_value(args.output.resolved())?;
            validate_value(args.filters.normalized())?;
        }
        Command::Ocr(args) => match &args.command {
            OcrCommand::Status(args) => {
                validate_value(args.output.resolved())?;
            }
            OcrCommand::Run(args) => {
                validate_value(args.output.resolved())?;
            }
        },
        Command::Recall(args) => {
            validate_value(args.output.resolved())?;
            validate_value(args.filters.normalized())?;
        }
        Command::Get(args) => {
            validate_value(args.output.resolved())?;
            validate_value(args.filters.normalized())?;
        }
        Command::Export(args) => {
            validate_value(args.output.resolved())?;
            validate_value(args.filters.normalized())?;
        }
        Command::Restore(args) => {
            validate_value(args.output.resolved())?;
        }
        Command::Forget(args) => {
            validate_value(args.output.resolved())?;
        }
        Command::Purge(args) => {
            validate_value(args.output.resolved())?;
        }
        Command::Storage(args) => match &args.command {
            StorageCommand::Compact(args) => {
                validate_value(args.output.resolved())?;
            }
            StorageCommand::OptimizeImages(args) => {
                validate_optimize_images_progress(args)?;
                validate_value(args.output.resolved())?;
            }
        },
        Command::Settings(args) => match &args.command {
            SettingsCommand::Show(args) => {
                validate_value(args.output.resolved())?;
            }
            SettingsCommand::Pause(_) | SettingsCommand::ApiKeyFilter(_) => {}
            SettingsCommand::Ocr(_) => {}
            SettingsCommand::Retention(_) => {}
            SettingsCommand::Ignore(args) => match &args.command {
                SettingsIgnoreCommand::Add(_) | SettingsIgnoreCommand::Remove(_) => {}
                SettingsIgnoreCommand::List(args) => {
                    validate_value(args.output.resolved())?;
                }
            },
        },
        Command::Watch(_) => {}
        Command::CaptureOnce(args) => {
            validate_json_human_flags(args.json, args.human)?;
        }
        Command::Doctor(args) => {
            validate_json_human_flags(args.json, args.human)?;
        }
    }

    Ok(())
}

fn validate_optimize_images_progress(
    args: &StorageOptimizeImagesArgs,
) -> std::result::Result<(), clap::Error> {
    if let Some(progress) = args.progress {
        if args.output.format.is_some() || args.output.json || args.output.human {
            return Err(clap_error(
                ErrorKind::ArgumentConflict,
                format!(
                    "`--progress {}` cannot be combined with `--format`, `--json`, or `--human`",
                    progress.as_str()
                ),
            ));
        }
    }
    Ok(())
}

pub(super) fn validate_json_human_flags(
    json: bool,
    human: bool,
) -> std::result::Result<(), clap::Error> {
    if json && human {
        Err(clap_error(
            ErrorKind::ArgumentConflict,
            "`--human` cannot be combined with `--json`",
        ))
    } else {
        Ok(())
    }
}