etz 0.3.0

CLI for coordinating git worktrees across multi-repo parent directories.
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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180

use std::collections::BTreeMap;

use serde::{Deserialize, Serialize};

pub const JSON_SCHEMA_VERSION: u32 = 1;

#[derive(Debug, Clone, Serialize)]
pub struct JsonEnvelope<T> {
    pub schema_version: u32,
    pub command: String,
    pub data: T,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ConfigFile {
    pub version: u32,
    pub workspace_dir: String,
    pub branch_strategy: String,
}

impl Default for ConfigFile {
    fn default() -> Self {
        Self {
            version: 1,
            workspace_dir: "workspaces".to_string(),
            branch_strategy: "create_from_default".to_string(),
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ManifestFile {
    pub version: u32,
    pub repos: Vec<ManifestRepo>,
}

impl Default for ManifestFile {
    fn default() -> Self {
        Self {
            version: 1,
            repos: Vec::new(),
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ManifestRepo {
    pub name: String,
    pub path: String,
    pub default_branch: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StateFile {
    pub version: u32,
    pub workspaces: BTreeMap<String, WorkspaceState>,
}

impl Default for StateFile {
    fn default() -> Self {
        Self {
            version: 1,
            workspaces: BTreeMap::new(),
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WorkspaceState {
    pub branch: String,
    pub repos: BTreeMap<String, WorkspaceRepoState>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WorkspaceRepoState {
    pub source_path: String,
    pub worktree_path: String,
}

#[derive(Debug, Clone, Serialize)]
pub struct RepoStatus {
    pub repo: String,
    pub source_path: String,
    pub worktree_path: String,
    pub exists: bool,
    pub branch: Option<String>,
    pub dirty: Option<bool>,
    pub staged_files: Option<u32>,
    pub unstaged_files: Option<u32>,
    pub untracked_files: Option<u32>,
    pub conflicts: Option<bool>,
    pub ahead: Option<u32>,
    pub behind: Option<u32>,
}

#[derive(Debug, Clone, Serialize)]
pub struct WorkspaceStatus {
    pub workspace: String,
    pub branch: String,
    pub repos: Vec<RepoStatus>,
}

#[derive(Debug, Clone, Serialize)]
pub struct StatusSummary {
    pub workspaces_total: u32,
    pub workspaces_shown: u32,
    pub repos_total: u32,
    pub repos_shown: u32,
    pub dirty_repos_total: u32,
    pub dirty_repos_shown: u32,
}

#[derive(Debug, Clone, Serialize)]
pub struct StatusResponse {
    pub changed_only: bool,
    pub summary: StatusSummary,
    pub workspaces: Vec<WorkspaceStatus>,
}

#[derive(Debug, Clone, Serialize)]
pub struct CommitSummary {
    pub workspace: String,
    pub branch: String,
    pub dry_run: bool,
    pub planned_commits: Vec<String>,
    pub auto_staged: Vec<String>,
    pub committed: Vec<String>,
    pub skipped: Vec<String>,
    pub rolled_back: Vec<String>,
    pub rollback_failed: Vec<String>,
}

#[derive(Debug, Clone, Serialize)]
pub struct PushRepoResult {
    pub repo: String,
    pub ahead: Option<u32>,
    pub behind: Option<u32>,
    pub pushed: bool,
    pub skipped_reason: Option<String>,
    pub error: Option<String>,
}

#[derive(Debug, Clone, Serialize)]
pub struct PushSummary {
    pub workspace: String,
    pub branch: String,
    pub dry_run: bool,
    pub pushed: Vec<String>,
    pub skipped: Vec<String>,
    pub failed: Vec<String>,
    pub repos: Vec<PushRepoResult>,
}

#[derive(Debug, Clone, Serialize)]
pub struct DoctorIssue {
    pub severity: String,
    pub code: String,
    pub message: String,
    pub workspace: Option<String>,
    pub repo: Option<String>,
    pub path: Option<String>,
    pub fix: Option<String>,
}

#[derive(Debug, Clone, Serialize)]
pub struct DoctorResponse {
    pub fix_mode: bool,
    pub fixes_applied: Vec<String>,
    pub issues: Vec<DoctorIssue>,
}

#[derive(Debug, Clone, Serialize)]
pub struct RefreshSummary {
    pub check_only: bool,
    pub drift_detected: bool,
    pub repos_total: u32,
    pub added: Vec<String>,
    pub removed: Vec<String>,
    pub updated: Vec<String>,
}