heddle-cli 0.3.1

An AI-native version control system
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

// SPDX-License-Identifier: Apache-2.0
//! Semantic facade for the CLI crate.

use std::path::PathBuf;

use objects::object::{ContentHash, FileChangeSet};
use repo::{Repository, WorktreeStatusOptions};
use semantic::diff::WorktreeStatus;
pub use semantic::diff::{
    SemanticCheckOnlyResult, SemanticCheckStatus, SemanticDiffOptions, SemanticFallbackReason,
    SemanticSummaryResult,
};

#[derive(Clone, Debug, Default)]
pub struct SemanticDiffResult {
    pub changes: Vec<objects::object::SemanticChange>,
    pub file_renames: Vec<(PathBuf, PathBuf)>,
    pub file_changes: FileChangeSet,
}

pub fn semantic_diff(
    repo: &Repository,
    from_tree_hash: &ContentHash,
    to_tree_hash: &ContentHash,
    options: &SemanticDiffOptions,
) -> Result<SemanticDiffResult, anyhow::Error> {
    let result =
        semantic::diff::semantic_diff(repo.store(), from_tree_hash, to_tree_hash, options)?;
    Ok(map_result(result))
}

pub fn semantic_check_only(
    repo: &Repository,
    from_tree_hash: &ContentHash,
    to_tree_hash: &ContentHash,
    options: &SemanticDiffOptions,
) -> Result<SemanticCheckOnlyResult, anyhow::Error> {
    semantic::diff::semantic_check_only(repo.store(), from_tree_hash, to_tree_hash, options)
}

pub fn semantic_diff_summary(
    repo: &Repository,
    from_tree_hash: &ContentHash,
    to_tree_hash: &ContentHash,
    options: &SemanticDiffOptions,
) -> Result<SemanticSummaryResult, anyhow::Error> {
    semantic::diff::semantic_diff_summary(repo.store(), from_tree_hash, to_tree_hash, options)
}

pub fn semantic_diff_worktree(
    repo: &Repository,
    from_tree_hash: &ContentHash,
    options: &SemanticDiffOptions,
    status_options: &WorktreeStatusOptions,
) -> Result<SemanticDiffResult, anyhow::Error> {
    let from_tree = repo.require_tree(from_tree_hash)?;
    let status = repo.compare_worktree_cached_with_options(&from_tree, status_options)?;

    let status = WorktreeStatus {
        modified: status.modified,
        added: status.added,
        deleted: status.deleted,
    };

    let result = semantic::diff::semantic_diff_worktree(
        repo.store(),
        from_tree_hash,
        repo.root(),
        &status,
        options,
    )?;

    Ok(map_result(result))
}

pub fn semantic_check_only_worktree(
    repo: &Repository,
    from_tree_hash: &ContentHash,
    options: &SemanticDiffOptions,
    status_options: &WorktreeStatusOptions,
) -> Result<SemanticCheckOnlyResult, anyhow::Error> {
    let from_tree = repo.require_tree(from_tree_hash)?;
    let status = repo.compare_worktree_cached_with_options(&from_tree, status_options)?;

    let status = WorktreeStatus {
        modified: status.modified,
        added: status.added,
        deleted: status.deleted,
    };

    semantic::diff::semantic_check_only_worktree(
        repo.store(),
        from_tree_hash,
        repo.root(),
        &status,
        options,
    )
}

pub fn semantic_diff_summary_worktree(
    repo: &Repository,
    from_tree_hash: &ContentHash,
    options: &SemanticDiffOptions,
    status_options: &WorktreeStatusOptions,
) -> Result<SemanticSummaryResult, anyhow::Error> {
    let from_tree = repo.require_tree(from_tree_hash)?;
    let status = repo.compare_worktree_cached_with_options(&from_tree, status_options)?;

    let status = WorktreeStatus {
        modified: status.modified,
        added: status.added,
        deleted: status.deleted,
    };

    semantic::diff::semantic_diff_summary_worktree(
        repo.store(),
        from_tree_hash,
        repo.root(),
        &status,
        options,
    )
}

fn map_result(result: semantic::diff::SemanticDiffResult) -> SemanticDiffResult {
    SemanticDiffResult {
        changes: result.changes,
        file_renames: result.file_renames,
        file_changes: result.file_changes,
    }
}