|
1
|
+ |
//! Guest plugin that scans a mounted `.git` directory for unreachable
|
|
2
|
+ |
//! commits and stash entries.
|
|
3
|
+ |
//!
|
|
4
|
+ |
//! It reads Git state directly: `HEAD`, loose refs, `packed-refs`, reflogs,
|
|
5
|
+ |
//! and loose objects. It does not shell out, does not call a `git` binary,
|
|
6
|
+ |
//! and does not parse packfiles. Output is a deterministic JSON value with
|
|
7
|
+ |
//! the current branch or detached HEAD, stash entries, and a bounded list
|
|
8
|
+ |
//! of lost commit candidates.
|
|
9
|
+ |
|
|
10
|
+ |
use openagents_pdk::{
|
|
11
|
+ |
list_mounted_dir, plugin_entry, read_mounted_file, MountDirListing, Refusal,
|
|
12
|
+ |
};
|
|
13
|
+ |
use serde::{Deserialize, Serialize};
|
|
14
|
+ |
use std::collections::{HashMap, HashSet};
|
|
15
|
+ |
|
|
16
|
+ |
const DEFAULT_MAX_LOST_COMMITS: usize = 50;
|
|
17
|
+ |
const MAX_LOST_COMMITS_CAP: usize = 100;
|
|
18
|
+ |
const ZERO_SHA: &str = "0000000000000000000000000000000000000000";
|
|
19
|
+ |
const HEAD_REF_PREFIX: &str = "ref: refs/heads/";
|
|
20
|
+ |
const REFS_DIR: &str = ".git/refs/heads";
|
|
21
|
+ |
const HEAD_PATH: &str = ".git/HEAD";
|
|
22
|
+ |
const PACKED_REFS_PATH: &str = ".git/packed-refs";
|
|
23
|
+ |
const HEAD_LOG_PATH: &str = ".git/logs/HEAD";
|
|
24
|
+ |
const HEADS_LOG_DIR: &str = ".git/logs/refs/heads";
|
|
25
|
+ |
const STASH_LOG_PATH: &str = ".git/logs/refs/stash";
|
|
26
|
+ |
const STASH_REF_PATH: &str = ".git/refs/stash";
|
|
27
|
+ |
const OBJECTS_DIR: &str = ".git/objects";
|
|
28
|
+ |
const GIT_DIR_ENTRY: &str = ".git";
|
|
29
|
+ |
|
|
30
|
+ |
#[derive(Deserialize)]
|
|
31
|
+ |
pub struct Input {
|
|
32
|
+ |
/// Maximum number of lost commits to report. Default 50, capped at 100.
|
|
33
|
+ |
#[serde(default)]
|
|
34
|
+ |
pub max_lost_commits: Option<usize>,
|
|
35
|
+ |
}
|
|
36
|
+ |
|
|
37
|
+ |
#[derive(Debug, Default, Serialize, PartialEq, Eq)]
|
|
38
|
+ |
pub struct Head {
|
|
39
|
+ |
/// The current branch name, or `null` when HEAD is detached or unknown.
|
|
40
|
+ |
pub branch: Option<String>,
|
|
41
|
+ |
/// The resolved SHA of HEAD, or `null` when it cannot be read.
|
|
42
|
+ |
pub sha: Option<String>,
|
|
43
|
+ |
}
|
|
44
|
+ |
|
|
45
|
+ |
#[derive(Debug, Serialize, PartialEq, Eq)]
|
|
46
|
+ |
pub struct StashEntry {
|
|
47
|
+ |
pub selector: String,
|
|
48
|
+ |
pub sha: String,
|
|
49
|
+ |
#[serde(skip_serializing_if = "Option::is_none")]
|
|
50
|
+ |
pub message: Option<String>,
|
|
51
|
+ |
pub timestamp: i64,
|
|
52
|
+ |
}
|
|
53
|
+ |
|
|
54
|
+ |
#[derive(Debug, Serialize, PartialEq, Eq)]
|
|
55
|
+ |
pub struct LostCommit {
|
|
56
|
+ |
pub sha: String,
|
|
57
|
+ |
#[serde(skip_serializing_if = "Option::is_none")]
|
|
58
|
+ |
pub action: Option<String>,
|
|
59
|
+ |
pub timestamp: i64,
|
|
60
|
+ |
pub packed: bool,
|
|
61
|
+ |
#[serde(skip_serializing_if = "Option::is_none")]
|
|
62
|
+ |
pub subject: Option<String>,
|
|
63
|
+ |
#[serde(skip_serializing_if = "Option::is_none")]
|
|
64
|
+ |
pub author: Option<String>,
|
|
65
|
+ |
#[serde(skip_serializing_if = "Option::is_none")]
|
|
66
|
+ |
pub author_date: Option<i64>,
|
|
67
|
+ |
}
|
|
68
|
+ |
|
|
69
|
+ |
#[derive(Debug, Default, Serialize, PartialEq, Eq)]
|
|
70
|
+ |
pub struct Summary {
|
|
71
|
+ |
pub total_lost_candidates: usize,
|
|
72
|
+ |
pub stashes_count: usize,
|
|
73
|
+ |
}
|
|
74
|
+ |
|
|
75
|
+ |
#[derive(Debug, Default, Serialize, PartialEq, Eq)]
|
|
76
|
+ |
pub struct Output {
|
|
77
|
+ |
pub head: Head,
|
|
78
|
+ |
pub stash_entries: Vec<StashEntry>,
|
|
79
|
+ |
pub lost_commits: Vec<LostCommit>,
|
|
80
|
+ |
pub summary: Summary,
|
|
81
|
+ |
}
|
|
82
|
+ |
|
|
83
|
+ |
/// The two host capabilities the scanner uses, abstracted so the core logic
|
|
84
|
+ |
/// runs under `cargo test` with a fake host and inside the WASM host.
|
|
85
|
+ |
pub trait Host {
|
|
86
|
+ |
fn list(&self, mount_index: u32, path: &str) -> Result<MountDirListing, Refusal>;
|
|
87
|
+ |
fn read(&self, path: &str) -> Result<Vec<u8>, Refusal>;
|
|
88
|
+ |
}
|
|
89
|
+ |
|
|
90
|
+ |
struct RealHost;
|
|
91
|
+ |
|
|
92
|
+ |
impl Host for RealHost {
|
|
93
|
+ |
fn list(&self, mount_index: u32, path: &str) -> Result<MountDirListing, Refusal> {
|
|
94
|
+ |
list_mounted_dir(mount_index, path)
|
|
95
|
+ |
}
|
|
96
|
+ |
fn read(&self, path: &str) -> Result<Vec<u8>, Refusal> {
|
|
97
|
+ |
read_mounted_file(path)
|
|
98
|
+ |
}
|
|
99
|
+ |
}
|
|
100
|
+ |
|
|
101
|
+ |
/// A one-line helper so failures are not thrown until the call site.
|
|
102
|
+ |
fn read_string(host: &dyn Host, path: &str) -> Option<String> {
|
|
103
|
+ |
host.read(path).ok().map(|b| String::from_utf8_lossy(&b).into_owned())
|
|
104
|
+ |
}
|
|
105
|
+ |
|
|
106
|
+ |
/// True when the text is 40 hexadecimal characters.
|
|
107
|
+ |
fn is_sha40(text: &str) -> bool {
|
|
108
|
+ |
text.len() == 40 && text.chars().all(|c| c.is_ascii_hexdigit())
|
|
109
|
+ |
}
|
|
110
|
+ |
|
|
111
|
+ |
/// Trim newlines and trailing whitespace from Git ref contents.
|
|
112
|
+ |
fn trim_ref(text: &str) -> &str {
|
|
113
|
+ |
text.trim_end_matches(|c: char| c == '\n' || c == '\r' || c == ' ' || c == '\t')
|
|
114
|
+ |
}
|
|
115
|
+ |
|
|
116
|
+ |
/// Resolve `HEAD` into a branch name and/or a SHA.
|
|
117
|
+ |
fn read_head(host: &dyn Host) -> Head {
|
|
118
|
+ |
let text = match read_string(host, HEAD_PATH) {
|
|
119
|
+ |
Some(t) => t,
|
|
120
|
+ |
None => return Head::default(),
|
|
121
|
+ |
};
|
|
122
|
+ |
let first = text.lines().next().unwrap_or("").trim();
|
|
123
|
+ |
if first.starts_with(HEAD_REF_PREFIX) {
|
|
124
|
+ |
let branch = first[HEAD_REF_PREFIX.len()..].trim().to_string();
|
|
125
|
+ |
let ref_path = format!(".git/refs/heads/{branch}");
|
|
126
|
+ |
let sha = read_string(host, &ref_path)
|
|
127
|
+ |
.as_deref()
|
|
128
|
+ |
.map(trim_ref)
|
|
129
|
+ |
.filter(|s| is_sha40(s))
|
|
130
|
+ |
.map(str::to_string);
|
|
131
|
+ |
Head {
|
|
132
|
+ |
branch: Some(branch),
|
|
133
|
+ |
sha,
|
|
134
|
+ |
}
|
|
135
|
+ |
} else {
|
|
136
|
+ |
let sha = trim_ref(first);
|
|
137
|
+ |
if is_sha40(sha) {
|
|
138
|
+ |
Head {
|
|
139
|
+ |
branch: None,
|
|
140
|
+ |
sha: Some(sha.to_string()),
|
|
141
|
+ |
}
|
|
142
|
+ |
} else {
|
|
143
|
+ |
Head::default()
|
|
144
|
+ |
}
|
|
145
|
+ |
}
|
|
146
|
+ |
}
|
|
147
|
+ |
|
|
148
|
+ |
/// Recursively list a directory and collect relative paths to all files
|
|
149
|
+ |
/// under it. Uses the host's confined listing import; failures stop descent.
|
|
150
|
+ |
fn collect_files_recursive(
|
|
151
|
+ |
host: &dyn Host,
|
|
152
|
+ |
mount_index: u32,
|
|
153
|
+ |
path: &str,
|
|
154
|
+ |
out: &mut Vec<String>,
|
|
155
|
+ |
) {
|
|
156
|
+ |
let listing = match host.list(mount_index, path) {
|
|
157
|
+ |
Ok(l) => l,
|
|
158
|
+ |
Err(_) => return,
|
|
159
|
+ |
};
|
|
160
|
+ |
for entry in listing.entries {
|
|
161
|
+ |
let child = if path.is_empty() {
|
|
162
|
+ |
entry.name
|
|
163
|
+ |
} else {
|
|
164
|
+ |
format!("{path}/{}", entry.name)
|
|
165
|
+ |
};
|
|
166
|
+ |
match entry.kind.as_str() {
|
|
167
|
+ |
"file" => out.push(child),
|
|
168
|
+ |
"dir" => collect_files_recursive(host, mount_index, &child, out),
|
|
169
|
+ |
_ => {}
|
|
170
|
+ |
}
|
|
171
|
+ |
}
|
|
172
|
+ |
}
|
|
173
|
+ |
|
|
174
|
+ |
/// Read every loose ref under `.git/refs/heads/` and return `(refname, sha)`.
|
|
175
|
+ |
fn read_loose_refs(host: &dyn Host) -> Vec<(String, String)> {
|
|
176
|
+ |
let mut files = Vec::new();
|
|
177
|
+ |
collect_files_recursive(host, 0, REFS_DIR, &mut files);
|
|
178
|
+ |
let mut out = Vec::new();
|
|
179
|
+ |
for file in files {
|
|
180
|
+ |
let name = file.strip_prefix(".git/refs/heads/").unwrap_or(&file).to_string();
|
|
181
|
+ |
let sha = match read_string(host, &file) {
|
|
182
|
+ |
Some(text) => trim_ref(&text).to_string(),
|
|
183
|
+ |
None => continue,
|
|
184
|
+ |
};
|
|
185
|
+ |
if is_sha40(&sha) {
|
|
186
|
+ |
out.push((name, sha));
|
|
187
|
+ |
}
|
|
188
|
+ |
}
|
|
189
|
+ |
out
|
|
190
|
+ |
}
|
|
191
|
+ |
|
|
192
|
+ |
/// Parse `packed-refs` for current ref tips. Skip comments and `^` peeled lines.
|
|
193
|
+ |
fn read_packed_refs(host: &dyn Host) -> Vec<(String, String)> {
|
|
194
|
+ |
let text = match read_string(host, PACKED_REFS_PATH) {
|
|
195
|
+ |
Some(t) => t,
|
|
196
|
+ |
None => return Vec::new(),
|
|
197
|
+ |
};
|
|
198
|
+ |
let mut out = Vec::new();
|
|
199
|
+ |
for line in text.lines() {
|
|
200
|
+ |
let line = line.trim();
|
|
201
|
+ |
if line.is_empty() || line.starts_with('#') || line.starts_with('^') {
|
|
202
|
+ |
continue;
|
|
203
|
+ |
}
|
|
204
|
+ |
let mut parts = line.split_whitespace();
|
|
205
|
+ |
let sha = parts.next().unwrap_or("");
|
|
206
|
+ |
let refname = parts.next().unwrap_or("");
|
|
207
|
+ |
if is_sha40(sha) && !refname.is_empty() {
|
|
208
|
+ |
out.push((refname.to_string(), sha.to_string()));
|
|
209
|
+ |
}
|
|
210
|
+ |
}
|
|
211
|
+ |
out
|
|
212
|
+ |
}
|
|
213
|
+ |
|
|
214
|
+ |
/// One raw reflog entry after parsing.
|
|
215
|
+ |
#[derive(Debug, Clone)]
|
|
216
|
+ |
struct ReflogEntry {
|
|
217
|
+ |
old: String,
|
|
218
|
+ |
new: String,
|
|
219
|
+ |
timestamp: i64,
|
|
220
|
+ |
message: String,
|
|
221
|
+ |
}
|
|
222
|
+ |
|
|
223
|
+ |
/// Parse a single reflog line into old/new SHA, timestamp, and message.
|
|
224
|
+ |
fn parse_reflog_line(line: &str) -> Option<ReflogEntry> {
|
|
225
|
+ |
if line.is_empty() || line.starts_with('#') {
|
|
226
|
+ |
return None;
|
|
227
|
+ |
}
|
|
228
|
+ |
let (prefix, message) = match line.find('\t') {
|
|
229
|
+ |
Some(idx) => (&line[..idx], &line[idx + 1..]),
|
|
230
|
+ |
None => (line, ""),
|
|
231
|
+ |
};
|
|
232
|
+ |
let prefix = prefix.trim_end();
|
|
233
|
+ |
let tokens: Vec<&str> = prefix.split_whitespace().collect();
|
|
234
|
+ |
if tokens.len() < 6 {
|
|
235
|
+ |
return None;
|
|
236
|
+ |
}
|
|
237
|
+ |
let old = tokens.first()?;
|
|
238
|
+ |
let new = tokens.get(1)?;
|
|
239
|
+ |
if !is_sha40(old) || !is_sha40(new) {
|
|
240
|
+ |
return None;
|
|
241
|
+ |
}
|
|
242
|
+ |
let tz = tokens.last()?;
|
|
243
|
+ |
if !tz.starts_with('+') && !tz.starts_with('-') {
|
|
244
|
+ |
return None;
|
|
245
|
+ |
}
|
|
246
|
+ |
let time_token = tokens.get(tokens.len() - 2)?;
|
|
247
|
+ |
let timestamp = time_token.parse::<i64>().ok()?;
|
|
248
|
+ |
Some(ReflogEntry {
|
|
249
|
+ |
old: old.to_string(),
|
|
250
|
+ |
new: new.to_string(),
|
|
251
|
+ |
timestamp,
|
|
252
|
+ |
message: message.trim_end_matches(|c: char| c == '\n' || c == '\r').to_string(),
|
|
253
|
+ |
})
|
|
254
|
+ |
}
|
|
255
|
+ |
|
|
256
|
+ |
/// Read a reflog file and parse every line that matches the expected shape.
|
|
257
|
+ |
fn read_reflog(host: &dyn Host, path: &str) -> Vec<ReflogEntry> {
|
|
258
|
+ |
let text = match read_string(host, path) {
|
|
259
|
+ |
Some(t) => t,
|
|
260
|
+ |
None => return Vec::new(),
|
|
261
|
+ |
};
|
|
262
|
+ |
text.lines().filter_map(parse_reflog_line).collect()
|
|
263
|
+ |
}
|
|
264
|
+ |
|
|
265
|
+ |
/// List the `.git/logs/refs/heads/` directory and read each branch reflog.
|
|
266
|
+ |
fn read_branch_reflogs(host: &dyn Host) -> Vec<ReflogEntry> {
|
|
267
|
+ |
let listing = match host.list(0, HEADS_LOG_DIR) {
|
|
268
|
+ |
Ok(l) => l,
|
|
269
|
+ |
Err(_) => return Vec::new(),
|
|
270
|
+ |
};
|
|
271
|
+ |
let mut out = Vec::new();
|
|
272
|
+ |
for entry in listing.entries {
|
|
273
|
+ |
if entry.kind != "file" {
|
|
274
|
+ |
continue;
|
|
275
|
+ |
}
|
|
276
|
+ |
let path = format!("{HEADS_LOG_DIR}/{}", entry.name);
|
|
277
|
+ |
out.extend(read_reflog(host, &path));
|
|
278
|
+ |
}
|
|
279
|
+ |
out
|
|
280
|
+ |
}
|
|
281
|
+ |
|
|
282
|
+ |
/// Stash entries from `logs/refs/stash`, falling back to `refs/stash`.
|
|
283
|
+ |
fn read_stash(host: &dyn Host) -> Vec<StashEntry> {
|
|
284
|
+ |
let mut out = Vec::new();
|
|
285
|
+ |
let mut index = 0i64;
|
|
286
|
+ |
for entry in read_reflog(host, STASH_LOG_PATH) {
|
|
287
|
+ |
out.push(StashEntry {
|
|
288
|
+ |
selector: format!("stash@{{{index}}}"),
|
|
289
|
+ |
sha: entry.new.clone(),
|
|
290
|
+ |
message: if entry.message.is_empty() { None } else { Some(entry.message) },
|
|
291
|
+ |
timestamp: entry.timestamp,
|
|
292
|
+ |
});
|
|
293
|
+ |
index += 1;
|
|
294
|
+ |
}
|
|
295
|
+ |
if out.is_empty() {
|
|
296
|
+ |
if let Some(text) = read_string(host, STASH_REF_PATH) {
|
|
297
|
+ |
let sha = trim_ref(&text).to_string();
|
|
298
|
+ |
if is_sha40(&sha) {
|
|
299
|
+ |
out.push(StashEntry {
|
|
300
|
+ |
selector: "stash@{0}".to_string(),
|
|
301
|
+ |
sha,
|
|
302
|
+ |
message: None,
|
|
303
|
+ |
timestamp: 0,
|
|
304
|
+ |
});
|
|
305
|
+ |
}
|
|
306
|
+ |
}
|
|
307
|
+ |
}
|
|
308
|
+ |
out
|
|
309
|
+ |
}
|
|
310
|
+ |
|
|
311
|
+ |
/// Read a loose object from `.git/objects/<first-2-hex>/<remaining-38-hex>`.
|
|
312
|
+ |
fn read_loose_object(host: &dyn Host, sha: &str) -> Option<Vec<u8>> {
|
|
313
|
+ |
let prefix = &sha[..2];
|
|
314
|
+ |
let suffix = &sha[2..];
|
|
315
|
+ |
let path = format!("{OBJECTS_DIR}/{prefix}/{suffix}");
|
|
316
|
+ |
host.read(&path).ok()
|
|
317
|
+ |
}
|
|
318
|
+ |
|
|
319
|
+ |
/// Decompress and parse a Git commit object. Returns `(subject, author, author_date)`.
|
|
320
|
+ |
fn parse_commit_object(bytes: &[u8]) -> Option<(String, String, i64)> {
|
|
321
|
+ |
let inflated = miniz_oxide::inflate::decompress_to_vec_zlib(bytes).ok()?;
|
|
322
|
+ |
let text = String::from_utf8_lossy(&inflated);
|
|
323
|
+ |
let null_pos = text.find('\0')?;
|
|
324
|
+ |
let header = &text[..null_pos];
|
|
325
|
+ |
if !header.starts_with("commit ") {
|
|
326
|
+ |
return None;
|
|
327
|
+ |
}
|
|
328
|
+ |
let body = &text[null_pos + 1..];
|
|
329
|
+ |
let mut author: Option<String> = None;
|
|
330
|
+ |
let mut author_date: Option<i64> = None;
|
|
331
|
+ |
let mut message_start: Option<usize> = None;
|
|
332
|
+ |
for (i, line) in body.lines().enumerate() {
|
|
333
|
+ |
if line.starts_with("author ") {
|
|
334
|
+ |
if let Some(rest) = line.strip_prefix("author ") {
|
|
335
|
+ |
author = Some(parse_author_name(rest));
|
|
336
|
+ |
author_date = parse_author_date(rest);
|
|
337
|
+ |
}
|
|
338
|
+ |
}
|
|
339
|
+ |
if line.is_empty() {
|
|
340
|
+ |
message_start = Some(body.lines().take(i + 1).map(|l| l.len() + 1).sum::<usize>());
|
|
341
|
+ |
break;
|
|
342
|
+ |
}
|
|
343
|
+ |
}
|
|
344
|
+ |
let message = if let Some(start) = message_start {
|
|
345
|
+ |
body.get(start..).unwrap_or("").to_string()
|
|
346
|
+ |
} else {
|
|
347
|
+ |
body.to_string()
|
|
348
|
+ |
};
|
|
349
|
+ |
let subject = message.trim().lines().next().unwrap_or("").to_string();
|
|
350
|
+ |
Some((subject, author.unwrap_or_default(), author_date.unwrap_or(0)))
|
|
351
|
+ |
}
|
|
352
|
+ |
|
|
353
|
+ |
/// Extract the human-readable author name and email from an `author` line.
|
|
354
|
+ |
fn parse_author_name(line: &str) -> String {
|
|
355
|
+ |
let email_end = match line.rfind('>') {
|
|
356
|
+ |
Some(idx) => idx,
|
|
357
|
+ |
None => return line.to_string(),
|
|
358
|
+ |
};
|
|
359
|
+ |
let before = &line[..=email_end];
|
|
360
|
+ |
before.to_string()
|
|
361
|
+ |
}
|
|
362
|
+ |
|
|
363
|
+ |
/// Extract the integer timestamp from an `author` line.
|
|
364
|
+ |
fn parse_author_date(line: &str) -> Option<i64> {
|
|
365
|
+ |
let email_end = line.rfind('>')?;
|
|
366
|
+ |
let tail = &line[email_end + 1..];
|
|
367
|
+ |
let mut parts = tail.split_whitespace();
|
|
368
|
+ |
parts.next()?.parse::<i64>().ok()
|
|
369
|
+ |
}
|
|
370
|
+ |
|
|
371
|
+ |
/// Determine whether the `.git` directory exists on the mount.
|
|
372
|
+ |
fn git_dir_present(host: &dyn Host) -> bool {
|
|
373
|
+ |
host.list(0, ".").ok().map_or(false, |l| {
|
|
374
|
+ |
l.entries.iter().any(|e| e.name == GIT_DIR_ENTRY && e.kind == "dir")
|
|
375
|
+ |
})
|
|
376
|
+ |
}
|
|
377
|
+ |
|
|
378
|
+ |
/// The whole scan, over any [`Host`]. Fail-soft: a missing `.git` or file
|
|
379
|
+ |
/// contributes an empty or partial result rather than a refusal.
|
|
380
|
+ |
pub fn scan(host: &dyn Host, input: &Input) -> Result<Output, Refusal> {
|
|
381
|
+ |
if !git_dir_present(host) {
|
|
382
|
+ |
return Ok(Output::default());
|
|
383
|
+ |
}
|
|
384
|
+ |
|
|
385
|
+ |
let head = read_head(host);
|
|
386
|
+ |
let max = input
|
|
387
|
+ |
.max_lost_commits
|
|
388
|
+ |
.unwrap_or(DEFAULT_MAX_LOST_COMMITS)
|
|
389
|
+ |
.clamp(1, MAX_LOST_COMMITS_CAP);
|
|
390
|
+ |
|
|
391
|
+ |
// Current ref tips: these SHAs are reachable and NOT lost.
|
|
392
|
+ |
let mut tips: HashSet<String> = HashSet::new();
|
|
393
|
+ |
if let Some(ref sha) = head.sha {
|
|
394
|
+ |
tips.insert(sha.clone());
|
|
395
|
+ |
}
|
|
396
|
+ |
for (_, sha) in read_loose_refs(host) {
|
|
397
|
+ |
tips.insert(sha);
|
|
398
|
+ |
}
|
|
399
|
+ |
for (refname, sha) in read_packed_refs(host) {
|
|
400
|
+ |
tips.insert(sha);
|
|
401
|
+ |
// A detached HEAD may be recorded as `HEAD` in packed-refs.
|
|
402
|
+ |
if refname == "HEAD" && head.sha.is_none() {
|
|
403
|
+ |
// already covered by tip set, no branch.
|
|
404
|
+ |
}
|
|
405
|
+ |
}
|
|
406
|
+ |
|
|
407
|
+ |
// Collect reflog candidates and remember the latest message/timestamp.
|
|
408
|
+ |
let mut candidate_actions: HashMap<String, (i64, String)> = HashMap::new();
|
|
409
|
+ |
for entry in read_reflog(host, HEAD_LOG_PATH).into_iter().chain(read_branch_reflogs(host)) {
|
|
410
|
+ |
let timestamp = entry.timestamp;
|
|
411
|
+ |
let message = &entry.message;
|
|
412
|
+ |
for sha in [entry.old, entry.new] {
|
|
413
|
+ |
if sha == ZERO_SHA {
|
|
414
|
+ |
continue;
|
|
415
|
+ |
}
|
|
416
|
+ |
update_candidate(&mut candidate_actions, sha, timestamp, message);
|
|
417
|
+ |
}
|
|
418
|
+ |
}
|
|
419
|
+ |
|
|
420
|
+ |
let stash = read_stash(host);
|
|
421
|
+ |
let mut lost: Vec<LostCommit> = Vec::new();
|
|
422
|
+ |
for (sha, (timestamp, action)) in candidate_actions {
|
|
423
|
+ |
if tips.contains(&sha) {
|
|
424
|
+ |
continue;
|
|
425
|
+ |
}
|
|
426
|
+ |
if let Some(bytes) = read_loose_object(host, &sha) {
|
|
427
|
+ |
if let Some((subject, author, author_date)) = parse_commit_object(&bytes) {
|
|
428
|
+ |
lost.push(LostCommit {
|
|
429
|
+ |
sha,
|
|
430
|
+ |
action: if action.is_empty() { None } else { Some(action) },
|
|
431
|
+ |
timestamp,
|
|
432
|
+ |
packed: false,
|
|
433
|
+ |
subject: if subject.is_empty() { None } else { Some(subject) },
|
|
434
|
+ |
author: if author.is_empty() { None } else { Some(author) },
|
|
435
|
+ |
author_date: if author_date == 0 { None } else { Some(author_date) },
|
|
436
|
+ |
});
|
|
437
|
+ |
} else {
|
|
438
|
+ |
// Unparsable object bytes: report as packed so as not to fail.
|
|
439
|
+ |
lost.push(LostCommit {
|
|
440
|
+ |
sha,
|
|
441
|
+ |
action: if action.is_empty() { None } else { Some(action) },
|
|
442
|
+ |
timestamp,
|
|
443
|
+ |
packed: true,
|
|
444
|
+ |
subject: None,
|
|
445
|
+ |
author: None,
|
|
446
|
+ |
author_date: None,
|
|
447
|
+ |
});
|
|
448
|
+ |
}
|
|
449
|
+ |
} else {
|
|
450
|
+ |
lost.push(LostCommit {
|
|
451
|
+ |
sha,
|
|
452
|
+ |
action: if action.is_empty() { None } else { Some(action) },
|
|
453
|
+ |
timestamp,
|
|
454
|
+ |
packed: true,
|
|
455
|
+ |
subject: None,
|
|
456
|
+ |
author: None,
|
|
457
|
+ |
author_date: None,
|
|
458
|
+ |
});
|
|
459
|
+ |
}
|
|
460
|
+ |
}
|
|
461
|
+ |
|
|
462
|
+ |
// Stable sort: timestamp descending, then sha ascending.
|
|
463
|
+ |
lost.sort_by(|a, b| b.timestamp.cmp(&a.timestamp).then(a.sha.cmp(&b.sha)));
|
|
464
|
+ |
let total_lost_candidates = lost.len();
|
|
465
|
+ |
lost.truncate(max);
|
|
466
|
+ |
|
|
467
|
+ |
let summary = Summary {
|
|
468
|
+ |
total_lost_candidates,
|
|
469
|
+ |
stashes_count: stash.len(),
|
|
470
|
+ |
};
|
|
471
|
+ |
|
|
472
|
+ |
Ok(Output {
|
|
473
|
+ |
head,
|
|
474
|
+ |
stash_entries: stash,
|
|
475
|
+ |
lost_commits: lost,
|
|
476
|
+ |
summary,
|
|
477
|
+ |
})
|
|
478
|
+ |
}
|
|
479
|
+ |
|
|
480
|
+ |
fn update_candidate(map: &mut HashMap<String, (i64, String)>, sha: String, timestamp: i64, message: &str) {
|
|
481
|
+ |
map.entry(sha)
|
|
482
|
+ |
.and_modify(|(t, m)| {
|
|
483
|
+ |
if timestamp > *t {
|
|
484
|
+ |
*t = timestamp;
|
|
485
|
+ |
*m = message.to_string();
|
|
486
|
+ |
}
|
|
487
|
+ |
})
|
|
488
|
+ |
.or_insert((timestamp, message.to_string()));
|
|
489
|
+ |
}
|
|
490
|
+ |
|
|
491
|
+ |
fn handle(input: Input) -> Result<Output, Refusal> {
|
|
492
|
+ |
scan(&RealHost, &input)
|
|
493
|
+ |
}
|
|
494
|
+ |
|
|
495
|
+ |
plugin_entry!(handle);
|
|
496
|
+ |
|
|
497
|
+ |
#[cfg(test)]
|
|
498
|
+ |
mod tests;
|