prikk 0.18.1

Prikk CLI initial scaffold.
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

//! Output for read-only merge evidence reports.

use prikk_store::{MergeEvidenceDisplay, MergeEvidenceDisplayOperation, MergePlanDisplay};

/// Print a read-only merge evidence report.
pub(crate) fn print_merge_evidence(report: &MergeEvidenceDisplay) {
    println!("merge evidence");
    println!("baseline block: {}", report.baseline_block_id);
    println!("left selector: {}", report.left_selector.selector);
    println!(
        "left target block: {}",
        report.left_selector.target_block_id
    );
    println!("left operations: {}", report.left_operation_count);
    println!("right selector: {}", report.right_selector.selector);
    println!(
        "right target block: {}",
        report.right_selector.target_block_id
    );
    println!("right operations: {}", report.right_operation_count);
    println!("outcome: {}", report.outcome);
    match report.reason {
        Some(reason) => println!("reason: {reason}"),
        None => println!("reason: <none>"),
    }
    println!(
        "items: {} displayed of {}",
        report.displayed_item_count(),
        report.total_item_count()
    );
    print_items(&report.items);
    println!(
        "note: read-only evidence; no merge commit, ref update, WAL write, or worktree change was performed"
    );
}

/// Print a read-only merge plan.
pub(crate) fn print_merge_plan(plan: &MergePlanDisplay) {
    let report = &plan.evidence;
    println!("merge plan");
    println!("baseline block: {}", report.baseline_block_id);
    println!("left selector: {}", report.left_selector.selector);
    println!(
        "left target block: {}",
        report.left_selector.target_block_id
    );
    println!("left operations: {}", report.left_operation_count);
    println!("right selector: {}", report.right_selector.selector);
    println!(
        "right target block: {}",
        report.right_selector.target_block_id
    );
    println!("right operations: {}", report.right_operation_count);
    println!("status: {}", plan.status);
    println!("evidence outcome: {}", report.outcome);
    match report.reason {
        Some(reason) => println!("reason: {reason}"),
        None => println!("reason: <none>"),
    }
    println!("action: {}", plan.action);
    println!(
        "items: {} displayed of {}",
        plan.displayed_item_count(),
        plan.total_item_count()
    );
    print_items(&report.items);
    println!(
        "note: read-only plan; no merge commit, ref update, WAL write, object write, or worktree change was performed"
    );
}

fn print_items(items: &[prikk_store::MergeEvidenceDisplayItem]) {
    for item in items {
        println!();
        println!("{}:", item.side);
        match item.side {
            "cross" => {
                print_labeled_operation("left", item.operation.as_ref());
                print_labeled_operation("right", item.peer_operation.as_ref());
            }
            "left" | "right" => print_labeled_operation(item.side, item.operation.as_ref()),
            "report" => {}
            side => {
                println!("  {side}");
            }
        }
        println!("  outcome: {}", item.outcome);
        println!("  reason: {}", item.reason_code);
        println!("  phase: {}", item.proof_phase);
        if let Some(scope) = item.evidence_scope {
            println!("  evidence-scope: {scope}");
        }
    }
}

fn print_labeled_operation(label: &str, operation: Option<&MergeEvidenceDisplayOperation>) {
    let Some(operation) = operation else {
        println!("  {label}");
        return;
    };
    print!("  {label}[{}]", operation.index);
    if let Some(op_seq) = operation.op_seq {
        print!(" op_seq={op_seq}");
    }
    if let Some(kind) = operation.kind {
        print!(" {kind}");
    }
    if let Some(path) = &operation.path {
        print!(" {path}");
    }
    println!();
}