jjj 0.4.1

Distributed project management and code review for Jujutsu
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

use crate::context::CommandContext;
use crate::error::Result;

/// Print the highest-priority next action(s) and their suggested commands.
///
/// `top` controls how many items to show (default 1; 0 means all).
/// `mine` restricts to work authored by the current user.
/// `claim` assigns the top item to the current user before displaying it.
/// The action list is the same one `jjj status` uses.
pub fn execute(
    ctx: &CommandContext,
    top: Option<usize>,
    mine: bool,
    json: bool,
    claim: bool,
) -> Result<()> {
    let store = &ctx.store;

    let problems = store.list_problems()?;
    let solutions = store.list_solutions()?;
    let critiques = store.list_critiques()?;

    let user = store.jj_client.user_identity().unwrap_or_default();

    let items =
        crate::commands::status::build_next_actions(&problems, &solutions, &critiques, &user, mine);

    if items.is_empty() {
        if json {
            println!("null");
        } else if claim {
            println!("Nothing to claim.");
        } else {
            println!("Nothing to do — all caught up!");
        }
        return Ok(());
    }

    // --claim: assign the top item to the current user, then display it
    if claim {
        let item = &items[0];
        let entity_type = item["entity_type"].as_str().unwrap_or("");
        let entity_id = item["entity_id"].as_str().unwrap_or("");

        match entity_type {
            "problem" => {
                store.with_metadata(
                    &format!("Claim problem {} for {}", entity_id, user),
                    || {
                        let mut problem = store.load_problem(entity_id)?;
                        if problem.assignee.as_deref() != Some(&user) {
                            problem.assignee = Some(user.clone());
                            store.save_problem(&problem)?;
                        }
                        Ok(())
                    },
                )?;
            }
            "solution" => {
                store.with_metadata(
                    &format!("Claim solution {} for {}", entity_id, user),
                    || {
                        let mut solution = store.load_solution(entity_id)?;
                        if solution.assignee.as_deref() != Some(&user) {
                            solution.assignee = Some(user.clone());
                            store.save_solution(&solution)?;
                        }
                        Ok(())
                    },
                )?;
            }
            // Critiques already have a reviewer — skip assignment
            _ => {}
        }

        if json {
            println!("{}", serde_json::to_string_pretty(&item)?);
        } else {
            let category = item["category"].as_str().unwrap_or("").to_uppercase();
            let title = item["title"].as_str().unwrap_or("");
            let summary = item["summary"].as_str().unwrap_or("");
            let cmd = item["suggested_command"].as_str().unwrap_or("");

            println!("Claimed: [{}] {} — {}", category, title, summary);
            if !cmd.is_empty() {
                println!("  -> {}", cmd);
            }
        }
        return Ok(());
    }

    // Determine how many items to show: top=None → 1, top=Some(0) → all, top=Some(n) → n
    let count = match top {
        None => 1,
        Some(0) => items.len(),
        Some(n) => n.min(items.len()),
    };

    let to_show = &items[..count];

    if json {
        if count == 1 {
            println!("{}", serde_json::to_string_pretty(&to_show[0])?);
        } else {
            println!("{}", serde_json::to_string_pretty(to_show)?);
        }
        return Ok(());
    }

    for (i, item) in to_show.iter().enumerate() {
        let category = item["category"].as_str().unwrap_or("").to_uppercase();
        let title = item["title"].as_str().unwrap_or("");
        let summary = item["summary"].as_str().unwrap_or("");
        let cmd = item["suggested_command"].as_str().unwrap_or("");

        if count > 1 {
            println!("{}. [{}] {} — {}", i + 1, category, title, summary);
        } else {
            println!("[{}] {} — {}", category, title, summary);
        }
        if !cmd.is_empty() {
            println!("  -> {}", cmd);
        }
    }

    Ok(())
}