git-slop 0.16.4

A deterministic repository token-defragmenter for humans and AI agents.
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

fn require_current_report(
    repo_root: &Path,
    report: &Value,
) -> Result<crate::freshness::ReportFreshness> {
    let freshness = crate::freshness::evaluate(repo_root, report)?;
    if freshness.current {
        return Ok(freshness);
    }
    Err(ClassifiedError::new(
        ErrorKind::Contract,
        "stale_report",
        format!(
            "Report is valid but stale: {}. Run `git slop find` and retry.",
            freshness.reason_codes()
        ),
    )
    .at("/report/freshness")
    .with_details(serde_json::to_value(&freshness)?)
    .into())
}

fn lexical_normalize(path: &Path) -> PathBuf {
    let mut result = PathBuf::new();
    for component in path.components() {
        match component {
            Component::CurDir => {}
            Component::ParentDir => {
                if !result.pop() {
                    result.push(component.as_os_str());
                }
            }
            _ => result.push(component.as_os_str()),
        }
    }
    result
}

fn selector_path(repo_root: &Path, input: &str) -> String {
    let candidate = if Path::new(input).is_absolute() {
        lexical_normalize(Path::new(input))
    } else {
        lexical_normalize(&repo_root.join(input))
    };
    candidate
        .strip_prefix(repo_root)
        .ok()
        .map(|path| path.to_string_lossy().replace('\\', "/"))
        .unwrap_or_else(|| match input.trim() {
            "" => ".".to_string(),
            trimmed => trimmed.to_string(),
        })
}

fn usage_error(error: impl std::fmt::Display) -> Result<i32> {
    Err(ClassifiedError::new(ErrorKind::Contract, "invalid_argument", error).into())
}

fn argument_error(
    pointer: &str,
    flag: &str,
    error: impl std::fmt::Display,
    actual: impl serde::Serialize,
) -> Result<i32> {
    Err(ClassifiedError::new(ErrorKind::Contract, "invalid_argument", error)
        .at(pointer)
        .with_details(json!({"flag": flag, "actual": actual}))
        .into())
}

fn ensure_prompt_pack_target(path: &Path) -> Result<()> {
    if path.exists() && !path.is_dir() {
        Err(ClassifiedError::new(
            ErrorKind::Contract,
            "prompt_pack_collision",
            format!("Prompt pack path is not a directory: {}", path.display()),
        )
        .at("/prompt_pack")
        .with_details(json!({"path": path}))
        .into())
    } else {
        Ok(())
    }
}