1use std::fmt::Write as _;
23use std::path::{Path, PathBuf};
24use std::time::Duration;
25
26use anyhow::{Context as _, Result, anyhow, bail};
27use serde::{Deserialize, Serialize};
28
29use crate::agent::{self, Invocation, SeatState};
30#[cfg(test)]
31use crate::ask;
32use crate::config::AgentSpec;
33use crate::git;
34use crate::land;
35use crate::notices::{Link, Notice, Notices};
36use crate::proc::Quiet as _;
37use crate::release_manifest;
38use crate::run::{self, RunState, RunStatus};
39use crate::verdict;
40
41#[derive(Debug, Clone, Serialize, Deserialize)]
43pub struct DecisionAttempt {
44 pub agent: String,
46 pub outcome: String,
48}
49
50async fn ask_decision(
53 state: &mut RunState,
54 repo: &Path,
55 prompt: &str,
56 timeout: Duration,
57) -> Result<(AgentSpec, SeatState, BumpDecision)> {
58 let chain = agent::pick_chain(
59 &state.config.agents,
60 state.config.roles.chatter.as_ref(),
61 &agent::installed,
62 "chatter (release-bump decision)",
63 )?;
64 let attempt_timeout = timeout / u32::try_from(chain.len()).unwrap_or(u32::MAX);
67 let artifacts = agent::artifacts_dir(&state.dir());
68 let cache = state.config.cache_dir();
69 let mut failures = Vec::new();
70 for (n, spec) in chain.iter().enumerate() {
71 let mut seat = crate::graph::handover_seat("bump", &spec.id, state.next_seat_seed());
72 let attempt = state.bump_decision_attempts.len() + 1;
75 let stem = format!("bump-decision-{attempt}");
76 state.event(
77 "bump",
78 format!("decision attempt {attempt}: trying {} ({stem})", spec.id),
79 );
80 let outcome = async {
82 let spec = agent::for_github_text(spec, &state.config.graph.github_language, repo)?;
83 agent::invoke(
84 &spec,
85 &mut seat,
86 &Invocation {
87 coordination: state.config.coordination.as_ref(),
88 fetched_base: None,
89 cwd: repo,
90 prompt,
91 timeout: attempt_timeout,
92 allow_write: false,
93 sessions: false,
94 artifacts: &artifacts,
95 stem: &stem,
96 run: &state.id,
97 node: "bump",
98 cache_dir: cache.as_deref(),
99 attachments: &[],
100 writable: &[],
101 },
102 )
103 .await
104 }
105 .await;
106 let parsed = if agent::chain_advances(&outcome) {
107 None
108 } else {
109 outcome
110 .as_ref()
111 .ok()
112 .and_then(|out| parse_decision(&out.text).ok())
113 };
114 let (class, reason) = match &outcome {
117 Ok(out) if out.quota_exhausted() => {
118 (run::FailClass::Quota, "rate/quota limit".to_owned())
119 }
120 Ok(out) if out.timed_out => (run::FailClass::Timeout, "timed out".to_owned()),
121 Ok(out) if out.exit_code != Some(0) => (
122 run::FailClass::Other("cli".into()),
123 format!(
124 "CLI failed ({})",
125 crate::notices::exit_status(out.exit_code)
126 ),
127 ),
128 Ok(out) if out.text.trim().is_empty() => (
129 run::FailClass::Other("empty".into()),
130 "empty output".to_owned(),
131 ),
132 Err(_) => (
133 run::FailClass::Other("cli".into()),
134 "CLI invocation failed; inspect attempt artifacts".to_owned(),
135 ),
136 _ => (
137 run::FailClass::Other("json".into()),
138 "invalid decision JSON or missing reason".to_owned(),
139 ),
140 };
141 let status = if parsed.is_some() {
142 "valid decision"
143 } else {
144 &reason
145 };
146 state.bump_decision_attempts.push(DecisionAttempt {
147 agent: spec.id.clone(),
148 outcome: status.to_owned(),
149 });
150 state.event(
151 "bump",
152 format!("decision attempt {attempt}: {}: {status}", spec.id),
153 );
154 if let Some(decision) = parsed {
155 return Ok((spec.clone(), seat, decision));
156 }
157 failures.push(format!("{}: {reason}", spec.id));
158 if let Some(next) = chain.get(n + 1) {
159 crate::graph::record_handover(
160 state, "bump", "bump", &spec.id, &next.id, &class, &reason,
161 );
162 }
163 }
164 bail!(
165 "release-bump decision exhausted {} eligible agent(s): {}. Check CLI subscription limits, availability and bump-decision attempt artifacts; adjust [roles] chatter or retry after recovery. No release PR was created by this decision",
166 chain.len(),
167 failures.join("; ")
168 )
169}
170
171async fn guard_reason(
174 state: &mut RunState,
175 repo: &Path,
176 prompt: &str,
177 spec: &AgentSpec,
178 seat: &mut SeatState,
179 decision: &mut BumpDecision,
180) {
181 let artifacts = agent::artifacts_dir(&state.dir());
182 let mut violations =
183 crate::github_text::check_for(&state.config.graph, "", &decision.reason, None);
184 violations.retain(|v| *v != crate::github_text::Violation::SensitiveData);
186 if violations.is_empty() {
187 decision.reason = crate::scrub::scrub(&decision.reason, &crate::scrub::Identity::current());
188 }
189 if state.config.graph.github_text_guard && !violations.is_empty() {
190 state.event(
191 "github-text",
192 format!("release reason rejected: {violations:?}; requesting one rewrite"),
193 );
194 let rewrite = format!(
195 "{prompt}\n\nYour release reason failed the GitHub text gate: {violations:?}. Return the same decision JSON with an English reason containing no local identity or secrets. Previous reason: {}",
196 decision.reason
197 );
198 let retry = async {
199 let spec = agent::for_github_text(spec, &state.config.graph.github_language, repo)?;
200 agent::invoke(
201 &spec,
202 seat,
203 &Invocation {
204 coordination: state.config.coordination.as_ref(),
205 fetched_base: None,
206 cwd: repo,
207 prompt: &rewrite,
208 timeout: crate::graph::retry_budget(DECISION_TIMEOUT, true),
209 allow_write: false,
210 sessions: false,
211 artifacts: &artifacts,
212 stem: "bump-rewrite",
213 run: &state.id,
214 node: "bump",
215 cache_dir: state.config.cache_dir().as_deref(),
216 attachments: &[],
217 writable: &[],
218 },
219 )
220 .await
221 }
222 .await;
223 let reason = retry
224 .ok()
225 .filter(|o| o.usable())
226 .and_then(|o| parse_decision(&o.text).ok())
227 .filter(|d| {
228 d.level == decision.level
229 && crate::github_text::check_for(&state.config.graph, "", &d.reason, None)
230 .is_empty()
231 })
232 .map(|d| d.reason);
233 if let Some(reason) = reason {
234 decision.reason = reason;
235 state.event("github-text", "release reason rewrite passed");
236 } else {
237 decision.reason = "The merged change requires a release.".to_owned();
238 state.event(
239 "github-text",
240 "release reason rewrite unavailable or rejected; using neutral text",
241 );
242 }
243 }
244}
245
246const DECISION_TIMEOUT: Duration = Duration::from_secs(600);
254
255pub fn should_release_bump(status: RunStatus) -> bool {
271 status == RunStatus::Merged
272}
273
274#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
276#[serde(rename_all = "lowercase")]
277pub enum BumpLevel {
278 Major,
280 Minor,
282 Patch,
284}
285
286impl BumpLevel {
287 pub fn as_str(self) -> &'static str {
289 match self {
290 Self::Major => "major",
291 Self::Minor => "minor",
292 Self::Patch => "patch",
293 }
294 }
295
296 fn severity(self) -> u8 {
301 match self {
302 Self::Patch => 0,
303 Self::Minor => 1,
304 Self::Major => 2,
305 }
306 }
307}
308
309#[derive(Debug, Clone, Deserialize)]
316pub struct BumpDecision {
317 pub level: BumpLevel,
319 pub reason: String,
322}
323
324pub fn parse_decision(text: &str) -> Result<BumpDecision> {
328 let decision: BumpDecision = verdict::extract_json(text)?;
329 if decision.reason.trim().is_empty() {
330 bail!("the bump decision carried no reason");
331 }
332 Ok(decision)
333}
334
335#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
338pub struct Version {
339 pub major: u64,
341 pub minor: u64,
343 pub patch: u64,
345}
346
347impl Version {
348 pub fn parse(s: &str) -> Result<Self> {
353 let s = s.trim();
354 let mut parts = s.splitn(3, '.');
355 let major = parts
356 .next()
357 .with_context(|| format!("`{s}` has no major component"))?;
358 let minor = parts
359 .next()
360 .with_context(|| format!("`{s}` has no minor component"))?;
361 let patch = parts
362 .next()
363 .with_context(|| format!("`{s}` has no patch component"))?;
364 let patch_digits: String = patch.chars().take_while(char::is_ascii_digit).collect();
365 Ok(Self {
366 major: major
367 .trim()
368 .parse()
369 .with_context(|| format!("`{major}` is not a number"))?,
370 minor: minor
371 .trim()
372 .parse()
373 .with_context(|| format!("`{minor}` is not a number"))?,
374 patch: patch_digits
375 .parse()
376 .with_context(|| format!("`{patch}` has no numeric patch component"))?,
377 })
378 }
379
380 #[must_use]
383 pub fn bump(self, level: BumpLevel) -> Self {
384 match level {
385 BumpLevel::Major => Self {
386 major: self.major + 1,
387 minor: 0,
388 patch: 0,
389 },
390 BumpLevel::Minor => Self {
391 major: self.major,
392 minor: self.minor + 1,
393 patch: 0,
394 },
395 BumpLevel::Patch => Self {
396 major: self.major,
397 minor: self.minor,
398 patch: self.patch + 1,
399 },
400 }
401 }
402}
403
404impl std::fmt::Display for Version {
405 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
406 write!(f, "{}.{}.{}", self.major, self.minor, self.patch)
407 }
408}
409
410pub fn is_release_only(files: &[String]) -> bool {
419 !files.is_empty() && files.iter().all(|f| f == "Cargo.toml" || f == "Cargo.lock")
420}
421
422fn rewrite_table_version(toml: &str, table: &str, new_version: &str) -> Result<String> {
433 let mut out = String::with_capacity(toml.len() + 8);
434 let mut in_table = false;
435 let mut done = false;
436 for line in toml.split_inclusive('\n') {
437 let trimmed = line.trim();
438 if trimmed.starts_with('[') {
439 in_table = trimmed == table;
440 }
441 if !done && in_table && trimmed.split('=').next().map(str::trim) == Some("version") {
442 let newline = if line.ends_with("\r\n") { "\r\n" } else { "\n" };
443 let _ = write!(out, "version = \"{new_version}\"{newline}");
444 done = true;
445 continue;
446 }
447 out.push_str(line);
448 }
449 if !done {
450 bail!("no `version` field found under `{table}`");
451 }
452 Ok(out)
453}
454
455fn strip_trailing_comment(s: &str) -> &str {
461 let mut in_string = false;
462 let mut quote = '"';
463 for (i, c) in s.char_indices() {
464 if in_string {
465 if c == quote {
466 in_string = false;
467 }
468 } else if c == '"' || c == '\'' {
469 in_string = true;
470 quote = c;
471 } else if c == '#' {
472 return s[..i].trim_end();
473 }
474 }
475 s
476}
477
478fn unquote_key(key: &str) -> &str {
484 for quote in ['"', '\''] {
485 if let Some(inner) = key.strip_prefix(quote).and_then(|k| k.strip_suffix(quote)) {
486 return inner;
487 }
488 }
489 key
490}
491
492fn extract_workspace_dependencies_fragment(toml: &str) -> String {
504 let mut fragment = String::new();
505 let mut capturing = false;
506 for line in toml.split_inclusive('\n') {
507 let header = strip_trailing_comment(line.trim());
508 if header.starts_with('[') {
509 if header == "[workspace.dependencies]" {
510 capturing = true;
511 fragment.push_str("[dependencies]\n");
512 } else if let Some(name) = header
513 .strip_prefix("[workspace.dependencies.")
514 .and_then(|rest| rest.strip_suffix(']'))
515 {
516 capturing = true;
517 let _ = writeln!(fragment, "[dependencies.{name}]");
518 } else {
519 capturing = false;
520 }
521 continue;
522 }
523 if capturing {
524 fragment.push_str(line);
525 }
526 }
527 fragment
528}
529
530fn internal_pin_names(toml: &str) -> Result<Vec<String>> {
548 let fragment = extract_workspace_dependencies_fragment(toml);
549 if fragment.trim().is_empty() {
550 return Ok(Vec::new());
551 }
552 let value: toml::Value =
553 toml::from_str(&fragment).context("failed to parse `[workspace.dependencies]` as TOML")?;
554 let mut names: Vec<String> = value
555 .get("dependencies")
556 .and_then(|d| d.as_table())
557 .into_iter()
558 .flatten()
559 .filter(|(_, dep)| {
560 dep.as_table()
561 .is_some_and(|t| t.contains_key("path") && t.contains_key("version"))
562 })
563 .map(|(name, _)| name.clone())
564 .collect();
565 names.sort();
566 Ok(names)
567}
568
569fn rewrite_quoted_field(line: &str, key: &str, new_value: &str) -> Option<String> {
579 let is_ident = |c: char| c.is_ascii_alphanumeric() || c == '_' || c == '-';
580 let mut search_from = 0;
581 while let Some(rel) = line[search_from..].find(key) {
582 let key_start = search_from + rel;
583 let before_ok = key_start == 0 || !is_ident(line[..key_start].chars().next_back().unwrap());
584 let eq_pos = key_start
585 + key.len()
586 + (line[key_start + key.len()..].len()
587 - line[key_start + key.len()..].trim_start().len());
588 if before_ok && line[eq_pos..].starts_with('=') {
589 let after_eq = &line[eq_pos + 1..];
590 let ws_len = after_eq.len() - after_eq.trim_start().len();
591 let quote_pos = eq_pos + 1 + ws_len;
592 if let Some(quote_char) = line[quote_pos..]
593 .chars()
594 .next()
595 .filter(|c| *c == '"' || *c == '\'')
596 {
597 let value_begin = quote_pos + quote_char.len_utf8();
598 if let Some(end_rel) = line[value_begin..].find(quote_char) {
599 let value_end = value_begin + end_rel;
600 let mut out = String::with_capacity(line.len());
601 out.push_str(&line[..value_begin]);
602 out.push_str(new_value);
603 out.push_str(&line[value_end..]);
604 return Some(out);
605 }
606 }
607 }
608 search_from = key_start + key.len();
609 }
610 None
611}
612
613fn rewrite_workspace_dependency_pins(
628 toml: &str,
629 names: &[String],
630 new_version: &str,
631) -> Result<String> {
632 if names.is_empty() {
633 return Ok(toml.to_owned());
634 }
635 let mut out = String::with_capacity(toml.len() + names.len() * 8);
636 let mut in_flat_table = false;
637 let mut in_named_table: Option<String> = None;
638 let mut rewritten: std::collections::HashSet<String> = std::collections::HashSet::new();
639
640 for line in toml.split_inclusive('\n') {
641 let trimmed = line.trim();
642 if trimmed.starts_with('[') {
643 let header = strip_trailing_comment(trimmed);
644 in_flat_table = header == "[workspace.dependencies]";
645 in_named_table = header
646 .strip_prefix("[workspace.dependencies.")
647 .and_then(|rest| rest.strip_suffix(']'))
648 .map(str::to_owned);
649 out.push_str(line);
650 continue;
651 }
652
653 let key = trimmed.split('=').next().map(str::trim).map(unquote_key);
654
655 if in_flat_table {
656 if let Some(name) = key.and_then(|k| names.iter().find(|n| n.as_str() == k)) {
658 if let Some(rewritten_line) = rewrite_quoted_field(line, "version", new_version) {
659 rewritten.insert(name.clone());
660 out.push_str(&rewritten_line);
661 continue;
662 }
663 } else if let Some(name) = key.and_then(|k| {
664 k.strip_suffix(".version")
665 .and_then(|prefix| names.iter().find(|n| n.as_str() == prefix))
666 }) {
667 if let Some(rewritten_line) = rewrite_quoted_field(line, "version", new_version) {
672 rewritten.insert(name.clone());
673 out.push_str(&rewritten_line);
674 continue;
675 }
676 }
677 } else if let Some(table_name) = &in_named_table {
678 if key == Some("version") && names.iter().any(|n| n == table_name) {
679 if let Some(rewritten_line) = rewrite_quoted_field(line, "version", new_version) {
680 rewritten.insert(table_name.clone());
681 out.push_str(&rewritten_line);
682 continue;
683 }
684 }
685 }
686
687 out.push_str(line);
688 }
689
690 for name in names {
691 if !rewritten.contains(name) {
692 bail!(
693 "could not rewrite the `[workspace.dependencies]` version pin \
694 for `{name}` - its `version` field was not found in a shape \
695 this rewrite understands"
696 );
697 }
698 }
699 Ok(out)
700}
701
702fn verify_pins_rewritten(toml: &str, names: &[String], new_version: &str) -> Result<()> {
710 let fragment = extract_workspace_dependencies_fragment(toml);
711 let value: toml::Value = toml::from_str(&fragment)
712 .context("rewritten `[workspace.dependencies]` failed to parse")?;
713 let deps = value.get("dependencies").and_then(|d| d.as_table());
714 for name in names {
715 let actual = deps
716 .and_then(|d| d.get(name))
717 .and_then(|dep| dep.as_table())
718 .and_then(|t| t.get("version"))
719 .and_then(|v| v.as_str());
720 if actual != Some(new_version) {
721 bail!(
722 "the `[workspace.dependencies]` version pin for `{name}` did \
723 not end up at `{new_version}` after the rewrite"
724 );
725 }
726 }
727 Ok(())
728}
729
730pub fn rewrite_cargo_version(toml: &str, new_version: &str) -> Result<String> {
752 let rewritten = rewrite_table_version(toml, "[package]", new_version)
753 .or_else(|_| rewrite_table_version(toml, "[workspace.package]", new_version))
754 .context("no `version` field found under `[package]` or `[workspace.package]`")?;
755
756 let pin_names = internal_pin_names(&rewritten)?;
757 if pin_names.is_empty() {
758 return Ok(rewritten);
759 }
760
761 let rewritten = rewrite_workspace_dependency_pins(&rewritten, &pin_names, new_version)?;
762 verify_pins_rewritten(&rewritten, &pin_names, new_version)?;
763 Ok(rewritten)
764}
765
766fn version_in_table(toml: &str, table: &str) -> Option<String> {
768 let mut in_table = false;
769 for line in toml.lines() {
770 let trimmed = line.trim();
771 if trimmed.starts_with('[') {
772 in_table = trimmed == table;
773 continue;
774 }
775 if !in_table {
776 continue;
777 }
778 let mut parts = trimmed.splitn(2, '=');
779 let key = parts.next().map(str::trim);
780 let Some(value) = parts.next() else {
781 continue;
782 };
783 if key == Some("version") {
784 return Some(value.trim().trim_matches('"').to_owned());
785 }
786 }
787 None
788}
789
790pub(crate) fn current_version(toml: &str) -> Result<String> {
795 version_in_table(toml, "[package]")
796 .or_else(|| version_in_table(toml, "[workspace.package]"))
797 .context("no `version` field found under `[package]` or `[workspace.package]`")
798}
799
800async fn branch_version(repo: &Path, remote: &str, branch: &str, primary: &str) -> Option<String> {
804 let from_name = branch.strip_prefix("chore/release-v").map(str::to_owned);
805 let tracking = format!("refs/remotes/{remote}/{branch}");
808 let spec = format!("+refs/heads/{branch}:{tracking}");
809 let fetched = git::git_raw(repo, &["fetch", "--quiet", remote, &spec]).await;
810 if fetched.is_ok_and(|o| o.code == Some(0))
811 && let Ok(out) = git::git_raw(repo, &["show", &format!("{tracking}:{primary}")]).await
812 && out.code == Some(0)
813 && let Ok(v) = current_version(&out.stdout)
814 {
815 return Some(v);
816 }
817 from_name
818}
819
820pub fn decision_prompt(
830 subject: &str,
831 instruction: &str,
832 diffstat: &str,
833 files: &[String],
834 current_version: &str,
835) -> String {
836 let mut s = format!(
837 "A pull request just merged into the base branch. Decide which digit \
838 of this project's `major.minor.patch` version this change earns, so \
839 a release bump can be opened for exactly it.\n\n\
840 Current version: {current_version}\n\n\
841 # Merge subject\n\n{subject}\n\n\
842 # The task that produced it\n\n{instruction}\n\n\
843 # Files changed ({} total)\n\n",
844 files.len()
845 );
846 const MAX_FILES: usize = 50;
847 for f in files.iter().take(MAX_FILES) {
848 let _ = writeln!(s, "- {f}");
849 }
850 if files.len() > MAX_FILES {
851 let _ = writeln!(s, "- ... and {} more", files.len() - MAX_FILES);
852 }
853 let _ = write!(s, "\n# Diffstat\n\n```\n{}\n```\n", diffstat.trim());
854
855 s.push_str(
856 "\n# How to decide\n\n\
857 This project is below version `1.0.0`. At that stage **`minor` is \
858 the digit that carries a breaking change** - do not spend `major` \
859 below `1.0.0`.\n\n\
860 A change is breaking, and earns `minor`, when it changes any of: \
861 the public API reachable from `src/lib.rs`, a CLI subcommand or \
862 flag, an HTTP API route or response shape, a configuration key, or \
863 the on-disk shape of persisted state.\n\n\
864 A user-visible new capability that breaks none of the above also \
865 earns `minor`.\n\n\
866 A fix, an internal refactor, or a dependency update earns `patch`.\n\n\
867 **When it is not obvious which digit applies, choose the larger \
868 one.** An oversized bump costs nothing; a breaking change shipped as \
869 `patch` breaks every downstream update that pins a range.\n\n\
870 # Output\n\n\
871 Reply with exactly one fenced JSON object and nothing that matters \
872 outside it:\n\n\
873 ```json\n\
874 {\"level\": \"major\" | \"minor\" | \"patch\", \"reason\": \"one line\"}\n\
875 ```\n",
876 );
877 let _ = write!(
879 s,
880 "\n{}\n\nThe `reason` goes into a GitHub pull request body, so write it \
881 in English.\n",
882 crate::prompt::GITHUB_ENGLISH_HEADING
883 );
884 s
885}
886
887#[derive(Debug, Clone, Serialize, Deserialize)]
903pub struct PendingBump {
904 pub target_version: String,
906 pub level: BumpLevel,
909 pub branch: String,
912 pub pr_url: String,
915}
916
917pub fn marker_path(home: &Path, repo: &Path) -> PathBuf {
921 let key = repo.to_string_lossy();
922 home.join("bump")
923 .join(format!("{:016x}.json", crate::rng::fnv1a(&key)))
924}
925
926pub fn read_marker(path: &Path) -> Option<PendingBump> {
930 let body = std::fs::read_to_string(path).ok()?;
931 serde_json::from_str(&body).ok()
932}
933
934pub fn write_marker(path: &Path, marker: &PendingBump) -> Result<()> {
938 if let Some(parent) = path.parent() {
939 std::fs::create_dir_all(parent).with_context(|| format!("create {}", parent.display()))?;
940 }
941 let body = serde_json::to_string_pretty(marker).context("serialize pending bump")?;
942 let tmp = path.with_extension("json.tmp");
943 std::fs::write(&tmp, &body).with_context(|| format!("write {}", tmp.display()))?;
944 std::fs::rename(&tmp, path).with_context(|| format!("replace {}", path.display()))?;
945 Ok(())
946}
947
948pub fn clear_marker(path: &Path) {
951 let _ = std::fs::remove_file(path);
952}
953
954#[derive(Debug, Clone, PartialEq, Eq)]
958pub enum Coalesce {
959 Proceed,
962 Skip {
964 target_version: String,
966 },
967}
968
969pub fn coalesce(pending: Option<&PendingBump>, current_version: &str) -> Result<Coalesce> {
971 let Some(pending) = pending else {
972 return Ok(Coalesce::Proceed);
973 };
974 let current = Version::parse(current_version)?;
975 let target = Version::parse(&pending.target_version)?;
976 if current >= target {
977 return Ok(Coalesce::Proceed);
978 }
979 Ok(Coalesce::Skip {
980 target_version: pending.target_version.clone(),
981 })
982}
983
984#[derive(Debug, Clone, Copy, PartialEq, Eq)]
986pub enum PendingAction {
987 AlreadyCovered,
990 Escalate,
993}
994
995pub fn pending_action(pending_level: BumpLevel, decision_level: BumpLevel) -> PendingAction {
1004 if decision_level.severity() > pending_level.severity() {
1005 PendingAction::Escalate
1006 } else {
1007 PendingAction::AlreadyCovered
1008 }
1009}
1010
1011fn parse_pr_state(json: &str) -> Result<bool> {
1013 #[derive(Deserialize)]
1014 struct State {
1015 state: String,
1016 }
1017 let parsed: State =
1018 serde_json::from_str(json).context("parse `gh pr view --json state` output")?;
1019 Ok(parsed.state.eq_ignore_ascii_case("OPEN"))
1020}
1021
1022async fn pr_is_open(repo: &Path, pr_url: &str) -> Result<bool> {
1035 let out = tokio::process::Command::new("gh")
1036 .args(["pr", "view", pr_url, "--json", "state"])
1037 .current_dir(repo)
1038 .quiet()
1039 .stdin(std::process::Stdio::null())
1040 .output()
1041 .await
1042 .context("spawn gh pr view")?;
1043 if !out.status.success() {
1044 bail!(
1045 "gh pr view {pr_url}: {}",
1046 String::from_utf8_lossy(&out.stderr).trim()
1047 );
1048 }
1049 parse_pr_state(&String::from_utf8_lossy(&out.stdout))
1050}
1051
1052const LOCK_STALE_AFTER: Duration = Duration::from_secs(30 * 60);
1060
1061struct MarkerLock {
1073 path: PathBuf,
1074}
1075
1076impl MarkerLock {
1077 #[cfg(test)]
1081 fn acquire(marker: &Path) -> Result<Option<Self>> {
1082 Self::acquire_with(marker, crate::lock_file::Retry::new(None))
1083 }
1084
1085 fn acquire_with(marker: &Path, retry: crate::lock_file::Retry) -> Result<Option<Self>> {
1086 let path = marker.with_extension("lock");
1087 if let Some(parent) = path.parent() {
1088 std::fs::create_dir_all(parent)
1089 .with_context(|| format!("create {}", parent.display()))?;
1090 }
1091 if Self::try_create(&path, retry)? {
1092 return Ok(Some(Self { path }));
1093 }
1094 if Self::is_stale(&path) {
1095 let _ = std::fs::remove_file(&path);
1096 if Self::try_create(&path, retry)? {
1097 return Ok(Some(Self { path }));
1098 }
1099 }
1100 Ok(None)
1101 }
1102
1103 fn try_create(path: &Path, retry: crate::lock_file::Retry) -> Result<bool> {
1104 match retry.create(path) {
1105 Ok(_) => Ok(true),
1106 Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => Ok(false),
1107 Err(e) => Err(e).with_context(|| format!("create {}", path.display())),
1108 }
1109 }
1110
1111 fn is_stale(path: &Path) -> bool {
1112 std::fs::metadata(path)
1113 .and_then(|m| m.modified())
1114 .ok()
1115 .and_then(|m| m.elapsed().ok())
1116 .is_some_and(|age| age >= LOCK_STALE_AFTER)
1117 }
1118}
1119
1120impl Drop for MarkerLock {
1121 fn drop(&mut self) {
1122 let _ = std::fs::remove_file(&self.path);
1123 }
1124}
1125
1126const LOCK_POLL: Duration = Duration::from_secs(5);
1128
1129const LOCK_WAIT_CEILING: Duration = Duration::from_secs(25 * 60);
1142
1143async fn wait_for_marker_lock(marker: &Path) -> Result<Option<MarkerLock>> {
1146 wait_for_marker_lock_with(marker, LOCK_POLL, LOCK_WAIT_CEILING).await
1147}
1148
1149async fn wait_for_marker_lock_with(
1153 marker: &Path,
1154 poll: Duration,
1155 ceiling: Duration,
1156) -> Result<Option<MarkerLock>> {
1157 let deadline = std::time::Instant::now() + ceiling;
1158 let retry = crate::lock_file::Retry::new(Some(deadline));
1159 loop {
1160 let marker = marker.to_owned();
1162 let acquired =
1163 tokio::task::spawn_blocking(move || MarkerLock::acquire_with(&marker, retry))
1164 .await
1165 .context("join marker lock acquisition")??;
1166 if let Some(lock) = acquired {
1167 return Ok(Some(lock));
1168 }
1169 let remaining = deadline.saturating_duration_since(std::time::Instant::now());
1170 if remaining.is_zero() {
1171 return Ok(None);
1172 }
1173 tokio::time::sleep(poll.min(remaining)).await;
1174 }
1175}
1176
1177fn level_between(from: Version, to: Version) -> Option<BumpLevel> {
1185 if to.major != from.major {
1186 Some(BumpLevel::Major)
1187 } else if to.minor != from.minor {
1188 Some(BumpLevel::Minor)
1189 } else if to.patch != from.patch {
1190 Some(BumpLevel::Patch)
1191 } else {
1192 None
1193 }
1194}
1195
1196fn parse_open_release_pr(json: &str) -> Result<Option<(String, String)>> {
1199 #[derive(Deserialize)]
1200 struct Pr {
1201 url: String,
1202 #[serde(rename = "headRefName")]
1203 head_ref_name: String,
1204 }
1205 let list: Vec<Pr> =
1206 serde_json::from_str(json).context("parse `gh pr list --json url,headRefName` output")?;
1207 Ok(list
1208 .into_iter()
1209 .find(|p| p.head_ref_name.starts_with("chore/release-v"))
1210 .map(|p| (p.head_ref_name, p.url)))
1211}
1212
1213pub(crate) fn parse_open_release_prs(json: &str) -> Result<Vec<(String, String)>> {
1216 #[derive(Deserialize)]
1217 struct Pr {
1218 url: String,
1219 #[serde(rename = "headRefName")]
1220 head_ref_name: String,
1221 }
1222 let list: Vec<Pr> =
1223 serde_json::from_str(json).context("parse `gh pr list --json url,headRefName` output")?;
1224 Ok(list
1225 .into_iter()
1226 .filter(|p| p.head_ref_name.starts_with("chore/release-v"))
1227 .map(|p| (p.head_ref_name, p.url))
1228 .collect())
1229}
1230
1231pub(crate) async fn list_open_release_prs(repo: &Path) -> Result<Vec<(String, String)>> {
1233 let out = tokio::process::Command::new("gh")
1234 .args([
1235 "pr",
1236 "list",
1237 "--state",
1238 "open",
1239 "--limit",
1240 "100",
1241 "--json",
1242 "url,headRefName",
1243 ])
1244 .current_dir(repo)
1245 .env_remove("GH_REPO")
1246 .quiet()
1247 .stdin(std::process::Stdio::null())
1248 .output()
1249 .await
1250 .context("spawn gh pr list")?;
1251 if !out.status.success() {
1252 bail!(
1253 "gh pr list: {}",
1254 String::from_utf8_lossy(&out.stderr).trim()
1255 );
1256 }
1257 parse_open_release_prs(&String::from_utf8_lossy(&out.stdout))
1258}
1259
1260async fn find_open_release_pr(repo: &Path) -> Result<Option<(String, String)>> {
1275 let out = tokio::process::Command::new("gh")
1276 .args(["pr", "list", "--state", "open", "--json", "url,headRefName"])
1277 .current_dir(repo)
1278 .quiet()
1279 .stdin(std::process::Stdio::null())
1280 .output()
1281 .await
1282 .context("spawn gh pr list")?;
1283 if !out.status.success() {
1284 bail!(
1285 "gh pr list: {}",
1286 String::from_utf8_lossy(&out.stderr).trim()
1287 );
1288 }
1289 parse_open_release_pr(&String::from_utf8_lossy(&out.stdout))
1290}
1291
1292pub async fn after_merge(state: &mut RunState, pr_url: &str) -> Result<()> {
1312 after_merge_at(state, pr_url, None, None).await
1313}
1314
1315#[derive(Debug, Default)]
1317struct Progress {
1318 version: Option<String>,
1320 pending_pr: Option<String>,
1322 skip: Option<Skip>,
1324}
1325
1326#[derive(Debug)]
1329struct Skip {
1330 reason: String,
1332 action: Option<String>,
1335}
1336
1337fn record_skip(state: &mut RunState, store: Option<&Notices>, skip: &Skip) {
1339 let record = state.release_bump.get_or_insert_with(Default::default);
1340 record.skipped = Some(skip.reason.clone());
1341 let Some(action) = &skip.action else {
1342 return;
1343 };
1344 record.action_required = Some(action.clone());
1345 let notice = Notice::error(
1346 &format!("release-bump:{}", state.id),
1347 format!(
1348 "Run {} merged, but its release bump was skipped: {action}.",
1349 state.id
1350 ),
1351 )
1352 .link(Link::Run {
1353 id: state.id.clone(),
1354 });
1355 let store = store.cloned().unwrap_or_else(Notices::open);
1356 if let Err(e) = store.raise_with(notice, &state.config.notify) {
1357 state.event("bump", format!("could not raise a notice: {e:#}"));
1358 }
1359 state.event("bump", format!("needs attention: {action}"));
1360}
1361
1362fn notice_for_failure(progress: &Progress, err: &anyhow::Error) -> (Option<String>, String) {
1368 (progress.version.clone(), format!("{err:#}"))
1369}
1370
1371fn failure_headline(reason: &str) -> Option<&str> {
1373 let lines = || {
1374 reason
1375 .lines()
1376 .map(str::trim)
1377 .filter(|line| !line.is_empty())
1378 };
1379 lines()
1380 .find(|line| line.starts_with("fatal:") || line.starts_with("error:"))
1381 .or_else(|| lines().next())
1382}
1383
1384#[cfg(test)]
1390async fn base_has_cargo_toml(repo: &Path, remote: &str, base: &str) -> Result<bool> {
1391 base_has_file(repo, remote, base, release_manifest::DEFAULT_PRIMARY).await
1392}
1393
1394async fn base_has_file(repo: &Path, remote: &str, base: &str, path: &str) -> Result<bool> {
1396 let out = git::git(
1397 repo,
1398 &[
1399 "ls-tree",
1400 "--name-only",
1401 &format!("{remote}/{base}"),
1402 "--",
1403 path,
1404 ],
1405 )
1406 .await
1407 .with_context(|| format!("look for {path} on the base branch"))?;
1408 Ok(!out.trim().is_empty())
1409}
1410
1411async fn change_base(dir: &Path, remote: &str, base: &str, branch: &str) -> Option<String> {
1415 let tip = git::rev_parse(dir, branch).await.ok()?;
1416 let mb = git::git(dir, &["merge-base", &format!("{remote}/{base}"), branch])
1417 .await
1418 .ok()?;
1419 let mb = mb.trim().to_owned();
1420 (!mb.is_empty() && mb != tip).then_some(mb)
1421}
1422
1423async fn primary_version_at(dir: &Path, rev: &str, path: &str) -> Option<String> {
1426 let out = git::git_raw(dir, &["show", &format!("{rev}:{path}")])
1427 .await
1428 .ok()?;
1429 if out.code != Some(0) {
1430 return None;
1431 }
1432 current_version(&out.stdout).ok()
1433}
1434
1435async fn after_merge_at(
1439 state: &mut RunState,
1440 pr_url: &str,
1441 home: Option<&Path>,
1442 store: Option<&Notices>,
1443) -> Result<()> {
1444 let mut progress = Progress::default();
1445 let result = after_merge_inner(state, pr_url, home, &mut progress).await;
1446 if let Some(skip) = &progress.skip {
1447 record_skip(state, store, skip);
1448 }
1449 if let Err(e) = &result {
1450 let (version, reason) = notice_for_failure(&progress, e);
1451 let pending = progress.pending_pr.as_deref();
1452 let store = store.cloned().unwrap_or_else(Notices::open);
1453 report_problem_in(
1454 state,
1455 &store,
1456 pending,
1457 version.as_deref(),
1458 &reason,
1459 pending.is_some(),
1460 )
1461 .await;
1462 }
1463 result
1464}
1465
1466async fn after_merge_inner(
1467 state: &mut RunState,
1468 pr_url: &str,
1469 home: Option<&Path>,
1470 progress: &mut Progress,
1471) -> Result<()> {
1472 if !state.config.merge.release_bump {
1473 return Ok(());
1474 }
1475 let Some(winner) = state.winner().cloned() else {
1476 return Ok(());
1477 };
1478 let repo = state.repo.clone();
1479 let base = state.base_branch.clone();
1480 let remote = state.config.merge.remote.clone();
1481
1482 let files = git::changed_files(&winner.worktree, &base, &winner.branch)
1483 .await
1484 .unwrap_or_default();
1485 let declared = state.config.release.version_files.clone();
1486 let custom = release_manifest::is_custom(&declared);
1487 let primary = release_manifest::primary_path(&declared).to_owned();
1488 if release_manifest::release_only(&files, &declared) {
1489 let mb = change_base(&winner.worktree, &remote, &base, &winner.branch).await;
1493 let unchanged = custom
1494 && match mb {
1495 Some(mb) => matches!(
1496 (
1497 primary_version_at(&winner.worktree, &mb, &primary).await,
1498 primary_version_at(&winner.worktree, &winner.branch, &primary).await,
1499 ),
1500 (Some(before), Some(after)) if before == after
1501 ),
1502 None => false,
1503 };
1504 if !unchanged {
1505 state.event(
1506 "bump",
1507 "the merged change touches only the release manifest; not treating it as a trigger",
1508 );
1509 progress.skip = Some(Skip {
1510 reason: "the merged change touches only the release files; not a trigger"
1511 .to_owned(),
1512 action: None,
1513 });
1514 return Ok(());
1515 }
1516 }
1517
1518 git::fetch(&repo, &remote, &base).await.ok();
1521 if !base_has_file(&repo, &remote, &base, &primary).await? {
1522 state.event(
1523 "bump",
1524 if custom {
1525 format!(
1526 "release bump: no {primary} on the base branch (from [release] version_files); skipping"
1527 )
1528 } else {
1529 "release bump: no Cargo.toml on the base branch; release bumps are Rust-only, skipping"
1530 .to_owned()
1531 },
1532 );
1533 let releases_by_workflow =
1536 base_has_file(&repo, &remote, &base, ".github/workflows/auto-tag.yml")
1537 .await
1538 .unwrap_or(false);
1539 let ja = crate::lang::is_japanese(&state.config.graph.language);
1540 let action = releases_by_workflow.then(|| {
1541 if ja {
1542 format!(
1543 "base ブランチに {primary} がありません。auto-tag.yml があるリポジトリです。magi.toml の [release] version_files に版の正本 (auto-tag.yml が読む Cargo.toml) を指定するか、リリースを手で行ってください"
1544 )
1545 } else {
1546 format!(
1547 "the base branch has no {primary} but does have .github/workflows/auto-tag.yml; set [release] version_files in magi.toml to the version of record auto-tag.yml reads, or release by hand"
1548 )
1549 }
1550 });
1551 progress.skip = Some(Skip {
1552 reason: format!("no {primary} on the base branch; no release bump was made"),
1553 action,
1554 });
1555 return Ok(());
1556 }
1557
1558 let marker = marker_path(&home.map_or_else(run::home, Path::to_path_buf), &repo);
1559 let Some(_lock) = wait_for_marker_lock(&marker).await? else {
1566 state.event(
1567 "bump",
1568 "another release bump decision held the lock past the wait ceiling; skipping this round",
1569 );
1570 return Ok(());
1571 };
1572
1573 git::fetch(&repo, &remote, &base).await.ok();
1574 let mut versions = Vec::new();
1575 for f in release_manifest::effective(&declared) {
1576 let text = git::git(&repo, &["show", &format!("{remote}/{base}:{}", f.path)])
1577 .await
1578 .with_context(|| format!("read {} from the base branch", f.path))?;
1579 let v = release_manifest::read_version(f.kind, &text)
1580 .with_context(|| format!("read the version of {}", f.path))?;
1581 versions.push((f.path, v));
1582 }
1583 let base_version = match release_manifest::agree(&versions) {
1584 Ok(v) => v,
1585 Err(e) => {
1586 let reason = format!("{e:#}");
1587 state.event("bump", format!("release bump skipped: {reason}"));
1588 progress.skip = Some(Skip {
1589 action: Some(format!("{reason}; align them by hand, then release")),
1590 reason,
1591 });
1592 return Ok(());
1593 }
1594 };
1595 if custom && !state.config.release.is_local() {
1598 let mb = change_base(&winner.worktree, &remote, &base, &winner.branch)
1604 .await
1605 .unwrap_or_default();
1606 if !mb.is_empty()
1607 && let (Some(before), Some(after)) = (
1608 primary_version_at(&winner.worktree, &mb, &primary).await,
1609 primary_version_at(&winner.worktree, &winner.branch, &primary).await,
1610 )
1611 && before != after
1612 {
1613 state.event(
1614 "bump",
1615 format!(
1616 "the merged change already moved {primary} from v{before} to v{after}; leaving the release to the repository's auto-tag"
1617 ),
1618 );
1619 progress.skip = Some(Skip {
1620 reason: format!(
1621 "the change itself raised {primary} from v{before} to v{after}; the repository's auto-tag releases it"
1622 ),
1623 action: None,
1624 });
1625 return Ok(());
1626 }
1627 }
1628
1629 let mut pending = read_marker(&marker);
1630 if let Some(p) = &pending {
1631 match coalesce(Some(p), &base_version)? {
1632 Coalesce::Proceed => {
1633 clear_marker(&marker);
1636 pending = None;
1637 }
1638 Coalesce::Skip { target_version } => {
1639 if !pr_is_open(&repo, &p.pr_url).await.unwrap_or(true) {
1640 state.event(
1641 "bump",
1642 format!(
1643 "the pending release bump to v{target_version} ({}) is no longer \
1644 open; treating it as abandoned",
1645 p.pr_url
1646 ),
1647 );
1648 clear_marker(&marker);
1649 pending = None;
1650 }
1651 }
1656 }
1657 }
1658
1659 if pending.is_none() {
1660 if let Ok(Some((branch, url))) = find_open_release_pr(&repo).await
1665 && let Some(target) = branch_version(&repo, &remote, &branch, &primary)
1666 .await
1667 .and_then(|v| Version::parse(&v).ok())
1668 {
1669 let base_parsed = Version::parse(&base_version)?;
1670 if target > base_parsed
1671 && let Some(level) = level_between(base_parsed, target)
1672 {
1673 let adopted = PendingBump {
1674 target_version: target.to_string(),
1675 level,
1676 branch,
1677 pr_url: url,
1678 };
1679 let _ = write_marker(&marker, &adopted);
1682 pending = Some(adopted);
1683 }
1684 }
1685 }
1686
1687 progress.pending_pr = pending.as_ref().map(|p| p.pr_url.clone());
1688 let title = pr_title(&repo, pr_url).await.unwrap_or_default();
1689 let subject = land::merge_subject(
1690 crate::graph::landing_title(state, &title),
1691 &crate::graph::landing_subject_source(state),
1692 );
1693 let stat = git::diff_stat(&winner.worktree, &base, &winner.branch)
1694 .await
1695 .unwrap_or_default();
1696 let prompt = decision_prompt(&subject, &state.instruction, &stat, &files, &base_version);
1697
1698 let (spec, mut seat, mut decision) =
1699 ask_decision(state, &repo, &prompt, DECISION_TIMEOUT).await?;
1700 guard_reason(state, &repo, &prompt, &spec, &mut seat, &mut decision).await;
1701
1702 if let Some(p) = pending {
1703 return match pending_action(p.level, decision.level) {
1704 PendingAction::AlreadyCovered => {
1705 state.event(
1706 "bump",
1707 format!(
1708 "a release bump to v{} ({}) already covers at least a {} change; not \
1709 opening another",
1710 p.target_version,
1711 p.pr_url,
1712 decision.level.as_str()
1713 ),
1714 );
1715 Ok(())
1716 }
1717 PendingAction::Escalate => {
1718 progress.version = Some(
1719 Version::parse(&base_version)?
1720 .bump(decision.level)
1721 .to_string(),
1722 );
1723 escalate_pending(state, &repo, &remote, &p, &decision, &base_version, &marker).await
1724 }
1725 };
1726 }
1727
1728 let next = Version::parse(&base_version)?
1729 .bump(decision.level)
1730 .to_string();
1731 progress.version = Some(next.clone());
1732 let branch = format!("chore/release-v{next}");
1733 let worktree = state.dir().join("bump");
1734 let (shared, branch_ref, next_ref, decision_ref) = (&mut *state, &branch, &next, &decision);
1735 let (pr_url_opened, outcome) =
1736 release_attempt(
1737 &repo,
1738 &remote,
1739 &base,
1740 &worktree,
1741 &branch,
1742 |head| {
1743 let repo = repo.clone();
1744 async move { gh_open_pr_for_head(&repo, &head).await }
1745 },
1746 |wt| async move {
1747 open_bump_pr(shared, &wt, branch_ref, next_ref, decision_ref, pr_url).await
1748 },
1749 )
1750 .await?;
1751 let local = outcome == AutomergeOutcome::LocalGate;
1752 let (automerge_warning, merged_detail) = match outcome {
1753 AutomergeOutcome::Enabled | AutomergeOutcome::LocalGate => (None, None),
1754 AutomergeOutcome::MergedDirectly { detail } => (None, Some(detail)),
1755 AutomergeOutcome::Failed { reason } => (Some(reason), None),
1756 };
1757
1758 let marker_write = write_marker(
1767 &marker,
1768 &PendingBump {
1769 target_version: next.clone(),
1770 level: decision.level,
1771 branch,
1772 pr_url: pr_url_opened.clone(),
1773 },
1774 );
1775 state.event(
1776 "bump",
1777 format!(
1778 "opened a {} release bump to v{next} ({}): {pr_url_opened}",
1779 decision.level.as_str(),
1780 decision.reason
1781 ),
1782 );
1783 if let Err(e) = marker_write {
1784 state.event(
1785 "bump",
1786 format!(
1787 "could not record the pending release bump marker for v{next}: {e:#}; a later \
1788 merge may open a duplicate pull request if it cannot find {pr_url_opened} on \
1789 the forge either"
1790 ),
1791 );
1792 }
1793 state.release_bump = Some(run::ReleaseBump {
1794 pr_url: Some(pr_url_opened.clone()),
1795 version: Some(next.clone()),
1796 automerge_enabled: automerge_warning.is_none() && merged_detail.is_none() && !local,
1797 merged_directly: merged_detail.is_some(),
1798 local,
1799 ..run::ReleaseBump::default()
1800 });
1801 if let Some(detail) = merged_detail {
1802 clear_marker(&marker);
1805 state.event("bump", format!("merged v{next} directly: {detail}"));
1806 }
1807 if let Some(warning) = automerge_warning {
1808 state.event(
1809 "bump",
1810 format!("could not enable automerge on {pr_url_opened}: {warning}; merge it by hand"),
1811 );
1812 report_problem(state, Some(&pr_url_opened), Some(&next), &warning).await;
1813 }
1814 Ok(())
1815}
1816
1817pub const NOTICE_NODE: &str = "release-bump";
1822
1823fn automerge_hint(reason: &str) -> &'static str {
1830 let r = reason.to_lowercase();
1831 if is_clean_status_refusal(reason) {
1832 "merge the release pull request by hand; CI is already green"
1833 } else if r.contains("enablepullrequestautomerge") || r.contains("protected branch rules") {
1834 "merge the release pull request by hand, and enable branch protection with required \
1835 status checks on the base branch so automerge can work next time"
1836 } else {
1837 "merge the release pull request by hand"
1838 }
1839}
1840
1841fn automerge_failure_comment(reason: &str) -> String {
1843 format!(
1844 "magi could not enable automerge on this pull request: {reason}\n\n\
1845 Action required: {}. Until then the release does not happen.",
1846 automerge_hint(reason)
1847 )
1848}
1849
1850#[cfg(test)]
1858fn surface_problem(
1859 state: &mut RunState,
1860 store: &Notices,
1861 pr_url: Option<&str>,
1862 version: Option<&str>,
1863 reason: &str,
1864) -> Result<(Notice, Option<String>)> {
1865 surface_problem_in(state, store, pr_url, version, reason, false)
1866}
1867
1868fn surface_problem_in(
1872 state: &mut RunState,
1873 store: &Notices,
1874 pr_url: Option<&str>,
1875 version: Option<&str>,
1876 reason: &str,
1877 pending: bool,
1878) -> Result<(Notice, Option<String>)> {
1879 let reason = crate::scrub::scrub(reason, &crate::scrub::Identity::current());
1880 let reason = reason.as_str();
1881 let action = if let (true, Some(url)) = (pending, pr_url) {
1882 let ja = crate::lang::is_japanese(&state.config.graph.language);
1883 let first = failure_headline(reason);
1884 let cause = first.map(|l| format!(" ({l})")).unwrap_or_default();
1885 if ja {
1886 let target = version.map(|v| format!(" v{v}")).unwrap_or_default();
1887 format!(
1888 "既存のリリース PR {url} を{target}へ更新できませんでした{cause}。PR を手で更新してください"
1889 )
1890 } else {
1891 let target = version.map(|v| format!(" to v{v}")).unwrap_or_default();
1892 format!(
1893 "the pending release pull request {url} could not be updated{target}{cause}; update it by hand"
1894 )
1895 }
1896 } else if pr_url.is_some() {
1897 automerge_hint(reason).to_owned()
1898 } else {
1899 let ja = crate::lang::is_japanese(&state.config.graph.language);
1900 let first = failure_headline(reason);
1901 if ja {
1902 let target = version.map(|v| format!(" (v{v})")).unwrap_or_default();
1903 let cause = first.map(|l| format!(" ({l})")).unwrap_or_default();
1904 format!(
1905 "リリースバンプ{target}は実行されませんでした{cause}。リリース PR を手で開いてください"
1906 )
1907 } else {
1908 let target = version.map(|v| format!(" to v{v}")).unwrap_or_default();
1909 let cause = first.map(|l| format!(" ({l})")).unwrap_or_default();
1910 format!(
1911 "the release bump{target} did not run{cause}; open the release pull request by hand"
1912 )
1913 }
1914 };
1915 let record = state.release_bump.get_or_insert_with(Default::default);
1916 record.pr_url = pr_url.map(str::to_owned).or(record.pr_url.take());
1917 record.version = version.map(str::to_owned).or(record.version.take());
1918 record.automerge_enabled = false;
1919 record.problem = Some(reason.to_owned());
1920 record.action_required = Some(action.clone());
1921
1922 let mut notice = Notice::error(
1923 &format!("release-bump:{}", state.id),
1924 format!(
1925 "Run {} merged, but its release step failed: {action}.",
1926 state.id
1927 ),
1928 );
1929 notice = match pr_url {
1930 Some(url) => notice.link(Link::Url {
1931 url: url.to_owned(),
1932 }),
1933 None => notice.link(Link::Run {
1934 id: state.id.clone(),
1935 }),
1936 };
1937 let notice = store
1938 .raise_with(
1939 notice
1940 .about([state.id.clone()])
1941 .for_run(Some(state.id.clone())),
1942 &state.config.notify,
1943 )
1944 .context("raise the release-bump notification")?;
1945 state.event("bump", format!("needs attention: {action}"));
1946 let comment = pr_url
1947 .filter(|_| !pending)
1948 .map(|_| automerge_failure_comment(reason));
1949 Ok((notice, comment))
1950}
1951
1952pub async fn report_problem(
1957 state: &mut RunState,
1958 pr_url: Option<&str>,
1959 version: Option<&str>,
1960 reason: &str,
1961) {
1962 report_problem_in(state, &Notices::open(), pr_url, version, reason, false).await;
1963}
1964
1965async fn report_problem_in(
1967 state: &mut RunState,
1968 store: &Notices,
1969 pr_url: Option<&str>,
1970 version: Option<&str>,
1971 reason: &str,
1972 pending: bool,
1973) {
1974 match surface_problem_in(state, store, pr_url, version, reason, pending) {
1975 Ok((_notice, comment)) => {
1976 if let (Some(url), Some(body)) = (pr_url, comment)
1977 && let Err(e) = gh_pr_comment(state, url, &body).await
1978 {
1979 state.event("bump", format!("could not comment on {url}: {e:#}"));
1980 }
1981 }
1982 Err(e) => state.event("bump", format!("could not raise a notice: {e:#}")),
1983 }
1984}
1985
1986pub(crate) async fn gh_pr_comment(state: &mut RunState, pr_url: &str, body: &str) -> Result<()> {
1987 let (_, body) = crate::github_text::prepare(state, "", body);
1988 let cwd = &state.repo;
1989 let out = tokio::process::Command::new("gh")
1990 .args(["pr", "comment", pr_url, "--body", &body])
1991 .current_dir(cwd)
1992 .quiet()
1993 .stdin(std::process::Stdio::null())
1994 .output()
1995 .await
1996 .context("spawn gh pr comment")?;
1997 if out.status.success() {
1998 Ok(())
1999 } else {
2000 bail!(
2001 "gh pr comment: {}",
2002 String::from_utf8_lossy(&out.stderr).trim()
2003 )
2004 }
2005}
2006
2007async fn escalate_pending(
2016 state: &mut RunState,
2017 repo: &Path,
2018 remote: &str,
2019 pending: &PendingBump,
2020 decision: &BumpDecision,
2021 base_version: &str,
2022 marker: &Path,
2023) -> Result<()> {
2024 let next = Version::parse(base_version)?
2025 .bump(decision.level)
2026 .to_string();
2027 let worktree = state.dir().join("bump");
2028 git::worktree_remove(repo, &worktree).await.ok();
2029 git::worktree_add_existing(repo, &worktree, &pending.branch, true)
2030 .await
2031 .with_context(|| format!("checking out the pending release branch {}", pending.branch))?;
2032
2033 let pushed: Result<()> = async {
2038 write_release_files(state, &worktree, &next).await?;
2039 let committed = git::commit_all(
2040 &worktree,
2041 &format!(
2042 "chore: release v{next} (supersedes v{})",
2043 pending.target_version
2044 ),
2045 )
2046 .await
2047 .context("commit the escalated version bump")?;
2048 if !committed {
2049 bail!("escalating the version bump left nothing to commit");
2050 }
2051 let pushed = git::push(&worktree, remote, &pending.branch).await?;
2052 if !pushed.ok() {
2053 bail!("pushing {} failed: {}", pending.branch, pushed.stderr);
2054 }
2055 Ok(())
2056 }
2057 .await;
2058 if let Err(e) = pushed {
2059 git::worktree_remove(repo, &worktree).await.ok();
2060 return Err(e);
2061 }
2062
2063 let (title, _) = crate::github_text::prepare(
2067 state,
2068 &format!("chore: release v{next} ({} bump)", decision.level.as_str()),
2069 "",
2070 );
2071 let title_warning = match gh_pr_edit_title(&worktree, &pending.pr_url, &title).await {
2072 Ok(()) => None,
2073 Err(e) => Some(e.to_string()),
2074 };
2075 git::worktree_remove(repo, &worktree).await.ok();
2076
2077 let marker_write = write_marker(
2078 marker,
2079 &PendingBump {
2080 target_version: next.clone(),
2081 level: decision.level,
2082 branch: pending.branch.clone(),
2083 pr_url: pending.pr_url.clone(),
2084 },
2085 );
2086 state.event(
2087 "bump",
2088 format!(
2089 "escalated the pending release bump from v{} to v{next} to a {} change ({}): {}",
2090 pending.target_version,
2091 decision.level.as_str(),
2092 decision.reason,
2093 pending.pr_url
2094 ),
2095 );
2096 if let Err(e) = marker_write {
2097 state.event(
2098 "bump",
2099 format!(
2100 "could not update the pending release bump marker to v{next}: {e:#}; a later \
2101 merge may misjudge whether it is already covered"
2102 ),
2103 );
2104 }
2105 if let Some(warning) = title_warning {
2106 state.event(
2107 "bump",
2108 format!(
2109 "pushed v{next} to {} but could not update its title: {warning}; the squashed \
2110 subject may still read the superseded version",
2111 pending.pr_url
2112 ),
2113 );
2114 }
2115 Ok(())
2116}
2117
2118async fn gh_open_pr_for_head(repo: &Path, branch: &str) -> Result<bool> {
2121 let out = tokio::process::Command::new("gh")
2122 .args([
2123 "pr", "list", "--head", branch, "--state", "open", "--json", "url",
2124 ])
2125 .current_dir(repo)
2126 .quiet()
2127 .stdin(std::process::Stdio::null())
2128 .output()
2129 .await
2130 .context("spawn gh pr list")?;
2131 if !out.status.success() {
2132 bail!(
2133 "gh pr list --head {branch}: {}",
2134 String::from_utf8_lossy(&out.stderr).trim()
2135 );
2136 }
2137 let prs: Vec<serde_json::Value> = serde_json::from_slice(&out.stdout)
2138 .with_context(|| format!("parse the pull requests headed by {branch}"))?;
2139 Ok(!prs.is_empty())
2140}
2141
2142async fn release_attempt<T, F, Fut, P, PFut>(
2151 repo: &Path,
2152 remote: &str,
2153 base: &str,
2154 worktree: &Path,
2155 branch: &str,
2156 open_pr: P,
2157 fill: F,
2158) -> Result<T>
2159where
2160 F: FnOnce(PathBuf) -> Fut,
2161 Fut: std::future::Future<Output = Result<T>>,
2162 P: Fn(String) -> PFut,
2163 PFut: std::future::Future<Output = Result<bool>>,
2164{
2165 let start = format!("{remote}/{base}");
2166 git::worktree_remove(repo, worktree).await.ok();
2167 let mut retried = false;
2168 if git::branch_exists(repo, branch).await? {
2169 reclaim_stale_branch(repo, remote, &start, branch, &open_pr).await?;
2170 retried = true;
2171 }
2172 loop {
2173 if let Err(e) = git::git(repo, &["branch", branch, &start]).await {
2178 let e = e.context("create the release branch");
2179 if !git::branch_exists(repo, branch).await.unwrap_or(false) {
2180 return Err(e);
2181 }
2182 if retried {
2184 return Err(anyhow!(
2185 "{e:#}; left {branch} in place: it is not one this attempt created"
2186 ));
2187 }
2188 retried = true;
2189 if let Err(r) = reclaim_stale_branch(repo, remote, &start, branch, &open_pr).await {
2190 return Err(anyhow!("{r:#} (after: {e:#})"));
2191 }
2192 continue;
2193 }
2194 if let Err(e) = git::worktree_add_existing(repo, worktree, branch, false).await {
2195 let e = e.context("create the release-bump worktree");
2196 return Err(discard_attempt(repo, remote, worktree, branch, e).await);
2197 }
2198 break;
2199 }
2200 match fill(worktree.to_path_buf()).await {
2201 Ok(v) => {
2202 git::worktree_remove(repo, worktree).await.ok();
2205 Ok(v)
2206 }
2207 Err(e) => Err(discard_attempt(repo, remote, worktree, branch, e).await),
2208 }
2209}
2210
2211async fn discard_attempt(
2213 repo: &Path,
2214 remote: &str,
2215 worktree: &Path,
2216 branch: &str,
2217 cause: anyhow::Error,
2218) -> anyhow::Error {
2219 git::worktree_remove(repo, worktree).await.ok();
2220 if !git::branch_exists(repo, branch).await.unwrap_or(false) {
2221 return cause;
2222 }
2223 let note = match git::remote_has_branch(repo, remote, branch).await {
2226 Ok(false) => match git::branch_delete(repo, branch).await {
2227 Ok(true) => return cause,
2228 _ => format!("could not delete the local branch {branch}"),
2229 },
2230 Ok(true) => format!("left {branch} in place: it was pushed to {remote}"),
2231 Err(e) => format!(
2232 "left {branch} in place: could not tell whether it was pushed to {remote} ({e:#})"
2233 ),
2234 };
2235 anyhow!("{cause:#}; {note}")
2236}
2237
2238async fn reclaim_stale_branch<P, PFut>(
2243 repo: &Path,
2244 remote: &str,
2245 start: &str,
2246 branch: &str,
2247 open_pr: &P,
2248) -> Result<()>
2249where
2250 P: Fn(String) -> PFut,
2251 PFut: std::future::Future<Output = Result<bool>>,
2252{
2253 match git::remote_has_branch(repo, remote, branch).await {
2254 Ok(false) => {}
2255 Ok(true) => bail!("the branch {branch} already exists and is on {remote}; left alone"),
2256 Err(e) => bail!(
2257 "the branch {branch} already exists and could not check whether {remote} has it ({e:#}); left alone"
2258 ),
2259 }
2260 match open_pr(branch.to_string()).await {
2261 Ok(false) => {}
2262 Ok(true) => {
2263 bail!("the branch {branch} already exists and has an open pull request; left alone")
2264 }
2265 Err(e) => bail!(
2266 "the branch {branch} already exists and could not check for an open pull request \
2267 ({e:#}); left alone"
2268 ),
2269 }
2270 match git::commits_ahead(repo, start, branch).await {
2271 Ok(0) => {}
2272 Ok(n) => bail!(
2273 "the branch {branch} already exists with {n} commit(s) not in {start}; left alone"
2274 ),
2275 Err(e) => bail!(
2276 "the branch {branch} already exists and could not compare it with {start} ({e:#}); \
2277 left alone"
2278 ),
2279 }
2280 if let Some(held) = git::worktree_holding(repo, branch).await? {
2281 let same = |a: &Path, b: &Path| match (a.canonicalize(), b.canonicalize()) {
2282 (Ok(a), Ok(b)) => a == b,
2283 _ => a == b,
2284 };
2285 if same(&held, repo) {
2286 bail!(
2287 "the branch {branch} already exists and is checked out in the main checkout; left alone"
2288 );
2289 }
2290 git::worktree_remove(repo, &held).await.ok();
2291 }
2292 if !git::branch_delete(repo, branch).await? {
2293 bail!("the branch {branch} already exists and could not be deleted; left alone");
2294 }
2295 Ok(())
2296}
2297
2298async fn open_bump_pr(
2304 state: &mut RunState,
2305 worktree: &Path,
2306 branch: &str,
2307 next_version: &str,
2308 decision: &BumpDecision,
2309 source_pr_url: &str,
2310) -> Result<(String, AutomergeOutcome)> {
2311 write_release_files(state, worktree, next_version).await?;
2312
2313 let committed = git::commit_all(worktree, &format!("chore: release v{next_version}"))
2314 .await
2315 .context("commit the version bump")?;
2316 if !committed {
2317 bail!("the version bump left nothing to commit");
2318 }
2319
2320 let remote = state.config.merge.remote.clone();
2321 let pushed = git::push(worktree, &remote, branch).await?;
2322 if !pushed.ok() {
2323 bail!("pushing {branch} failed: {}", pushed.stderr);
2324 }
2325
2326 let (title, body) = release_pr(
2327 decision.level.as_str(),
2328 &decision.reason,
2329 next_version,
2330 &state.id,
2331 source_pr_url,
2332 );
2333 let (title, body) = crate::github_text::prepare(state, &title, &body);
2334 let url = gh_pr_create(worktree, &state.base_branch, branch, &title, &body).await?;
2335 if state.config.release.is_local() {
2339 crate::release_watch::register(&crate::run::home(), &state.repo, &url, &state.id);
2342 return Ok((url, AutomergeOutcome::LocalGate));
2343 }
2344 let outcome = match gh_enable_automerge(worktree, &url).await {
2345 Ok(()) => AutomergeOutcome::Enabled,
2346 Err(e) => {
2347 let reason = e.to_string();
2348 if is_clean_status_refusal(&reason) {
2349 gh_merge_directly(worktree, &url, &title, reason).await
2350 } else {
2351 AutomergeOutcome::Failed { reason }
2352 }
2353 }
2354 };
2355 Ok((url, outcome))
2356}
2357
2358#[derive(Debug, Clone, PartialEq, Eq)]
2360enum AutomergeOutcome {
2361 Enabled,
2363 MergedDirectly { detail: String },
2365 LocalGate,
2367 Failed { reason: String },
2369}
2370
2371fn is_clean_status_refusal(reason: &str) -> bool {
2377 let r = reason.to_lowercase();
2378 r.contains("is in clean status") && r.contains("enablepullrequestautomerge")
2379}
2380
2381pub(crate) fn bump_merge_argv(pr_url: &str, subject: &str) -> Vec<String> {
2384 [
2385 "pr",
2386 "merge",
2387 pr_url,
2388 "--squash",
2389 "--delete-branch",
2390 "--subject",
2391 subject,
2392 ]
2393 .map(str::to_owned)
2394 .to_vec()
2395}
2396
2397fn resolve_direct_merge(
2401 refusal: &str,
2402 argv: &[String],
2403 merge_ok: bool,
2404 stderr: &str,
2405 after: Option<land::PrLifecycle>,
2406) -> AutomergeOutcome {
2407 if merge_ok {
2408 return AutomergeOutcome::MergedDirectly {
2409 detail: format!("automerge was refused ({refusal}); gh {}", argv.join(" ")),
2410 };
2411 }
2412 match land::merged_after_all(argv, stderr, after) {
2413 Some(m) => AutomergeOutcome::MergedDirectly { detail: m.detail },
2414 None => AutomergeOutcome::Failed {
2415 reason: format!("{refusal}; merging directly failed too: {}", stderr.trim()),
2416 },
2417 }
2418}
2419
2420async fn gh_merge_directly(
2424 cwd: &Path,
2425 pr_url: &str,
2426 subject: &str,
2427 refusal: String,
2428) -> AutomergeOutcome {
2429 let argv = bump_merge_argv(pr_url, subject);
2430 let out = match tokio::process::Command::new("gh")
2431 .args(&argv)
2432 .current_dir(cwd)
2433 .quiet()
2434 .stdin(std::process::Stdio::null())
2435 .output()
2436 .await
2437 {
2438 Ok(o) => o,
2439 Err(e) => {
2440 return AutomergeOutcome::Failed {
2441 reason: format!("{refusal}; could not spawn gh to merge directly: {e}"),
2442 };
2443 }
2444 };
2445 let stderr = String::from_utf8_lossy(&out.stderr).into_owned();
2446 let after = if out.status.success() {
2449 None
2450 } else {
2451 land::lifecycle(cwd, pr_url).await.ok()
2452 };
2453 resolve_direct_merge(&refusal, &argv, out.status.success(), &stderr, after)
2454}
2455
2456async fn write_release_files(state: &RunState, worktree: &Path, version: &str) -> Result<()> {
2460 let declared = &state.config.release.version_files;
2461 if release_manifest::is_custom(declared) {
2462 return release_manifest::apply(worktree, declared, version);
2463 }
2464 let cargo_toml_path = worktree.join("Cargo.toml");
2465 let toml = tokio::fs::read_to_string(&cargo_toml_path)
2466 .await
2467 .with_context(|| format!("read {}", cargo_toml_path.display()))?;
2468 let rewritten = rewrite_cargo_version(&toml, version)?;
2469 tokio::fs::write(&cargo_toml_path, rewritten)
2470 .await
2471 .with_context(|| format!("write {}", cargo_toml_path.display()))?;
2472 sync_lockfile(worktree, state.config.cache_dir().as_deref()).await
2473}
2474
2475async fn sync_lockfile(worktree: &Path, cache_dir: Option<&Path>) -> Result<()> {
2483 let mut cmd = tokio::process::Command::new("cargo");
2484 cmd.arg("build").current_dir(worktree).quiet();
2485 crate::incremental::configure(&mut cmd, worktree)?;
2486 if let Some(dir) = cache_dir {
2487 cmd.env("CARGO_TARGET_DIR", dir);
2488 }
2489 let out = cmd
2490 .stdin(std::process::Stdio::null())
2491 .output()
2492 .await
2493 .context("spawn cargo build")?;
2494 if !out.status.success() {
2495 bail!(
2496 "cargo build failed while syncing Cargo.lock: {}",
2497 String::from_utf8_lossy(&out.stderr).trim()
2498 );
2499 }
2500 Ok(())
2501}
2502
2503fn release_pr(
2508 level: &str,
2509 reason: &str,
2510 next_version: &str,
2511 run_id: &str,
2512 source_pr_url: &str,
2513) -> (String, String) {
2514 let title = format!("chore: release v{next_version} ({level} bump)");
2515 let body = format!(
2516 "## Background\n\n\
2517 A change that was just merged is a `{level}` change, so the crate needs a new \
2518 release: {reason}\n\n\
2519 Triggered by magi run `{run_id}`, which landed {source}.\n\n\
2520 ## Change\n\n\
2521 Raises the package version to `v{next_version}` in `Cargo.toml`, with \
2522 `Cargo.lock` following it. Nothing else changes.\n\n\
2523 ## Risk\n\n\
2524 Version-bump-only, so there is nothing here for a reviewer to find. Merging \
2525 it starts the release pipeline (auto-tag, then the release workflow).",
2526 source = source_pr_url,
2527 );
2528 (title, body)
2529}
2530
2531async fn pr_title(repo: &Path, pr_url: &str) -> Result<String> {
2533 let out = tokio::process::Command::new("gh")
2534 .args(["pr", "view", pr_url, "--json", "title"])
2535 .current_dir(repo)
2536 .quiet()
2537 .stdin(std::process::Stdio::null())
2538 .output()
2539 .await
2540 .context("spawn gh pr view")?;
2541 if !out.status.success() {
2542 bail!(
2543 "gh pr view {pr_url}: {}",
2544 String::from_utf8_lossy(&out.stderr).trim()
2545 );
2546 }
2547 #[derive(Deserialize)]
2548 struct Title {
2549 title: String,
2550 }
2551 let parsed: Title = serde_json::from_str(&String::from_utf8_lossy(&out.stdout))
2552 .context("parse `gh pr view --json title` output")?;
2553 Ok(parsed.title)
2554}
2555
2556async fn gh_pr_create(
2557 cwd: &Path,
2558 base: &str,
2559 head: &str,
2560 title: &str,
2561 body: &str,
2562) -> Result<String> {
2563 let out = tokio::process::Command::new("gh")
2564 .args([
2565 "pr", "create", "--base", base, "--head", head, "--title", title, "--body", body,
2566 ])
2567 .current_dir(cwd)
2568 .quiet()
2569 .stdin(std::process::Stdio::null())
2570 .output()
2571 .await
2572 .context("spawn gh pr create")?;
2573 if out.status.success() {
2574 Ok(String::from_utf8_lossy(&out.stdout).trim().to_owned())
2575 } else {
2576 bail!(
2577 "gh pr create: {}",
2578 String::from_utf8_lossy(&out.stderr).trim()
2579 )
2580 }
2581}
2582
2583async fn gh_enable_automerge(cwd: &Path, pr_url: &str) -> Result<()> {
2587 let out = tokio::process::Command::new("gh")
2588 .args([
2589 "pr",
2590 "merge",
2591 pr_url,
2592 "--auto",
2593 "--squash",
2594 "--delete-branch",
2595 ])
2596 .current_dir(cwd)
2597 .quiet()
2598 .stdin(std::process::Stdio::null())
2599 .output()
2600 .await
2601 .context("spawn gh pr merge --auto")?;
2602 if out.status.success() {
2603 Ok(())
2604 } else {
2605 bail!(
2606 "gh pr merge --auto: {}",
2607 String::from_utf8_lossy(&out.stderr).trim()
2608 )
2609 }
2610}
2611
2612async fn gh_pr_edit_title(cwd: &Path, pr_url: &str, title: &str) -> Result<()> {
2616 let out = tokio::process::Command::new("gh")
2617 .args(["pr", "edit", pr_url, "--title", title])
2618 .current_dir(cwd)
2619 .quiet()
2620 .stdin(std::process::Stdio::null())
2621 .output()
2622 .await
2623 .context("spawn gh pr edit")?;
2624 if out.status.success() {
2625 Ok(())
2626 } else {
2627 bail!(
2628 "gh pr edit --title: {}",
2629 String::from_utf8_lossy(&out.stderr).trim()
2630 )
2631 }
2632}
2633
2634#[cfg(test)]
2635mod tests {
2636 use super::*;
2637 use crate::notices::Severity;
2638
2639 #[test]
2640 fn github_facing_bump_text_is_english() {
2641 let (title, body) =
2642 release_pr("minor", "adds a flag", "0.37.0", "ab12", "https://x/pull/1");
2643 assert!(crate::github_text::check(&title, &body).is_empty());
2644 assert!(title.is_ascii() && body.is_ascii(), "{title}\n{body}");
2645 assert_eq!(title, "chore: release v0.37.0 (minor bump)");
2646 assert!(
2647 body.contains("## Background") && body.contains("## Change"),
2648 "{body}"
2649 );
2650 let p = decision_prompt("s", "i", "d", &[], "0.36.5");
2651 assert!(p.contains(crate::prompt::GITHUB_ENGLISH_HEADING), "{p}");
2652 }
2653 use crate::config::Config;
2654 use crate::land::PrLifecycle;
2655
2656 #[tokio::test]
2662 async fn a_disabled_config_does_nothing() {
2663 let config = Config {
2664 merge: crate::config::Merge {
2665 release_bump: false,
2666 ..crate::config::Merge::default()
2667 },
2668 ..Config::default()
2669 };
2670 let mut state = RunState::new(
2671 PathBuf::from("/no/such/repo"),
2672 "main".to_owned(),
2673 "0000000000000000000000000000000000000000".to_owned(),
2674 "irrelevant".to_owned(),
2675 config,
2676 );
2677 after_merge(&mut state, "https://example.invalid/pull/1")
2678 .await
2679 .expect("a disabled config must return Ok without touching anything");
2680 assert!(
2681 state.events.is_empty(),
2682 "nothing should happen at all, not even a logged event"
2683 );
2684 }
2685
2686 async fn origin_with(files: &[(&str, &str)]) -> (tempfile::TempDir, PathBuf) {
2688 let dir = tempfile::tempdir().unwrap();
2689 let origin = dir.path().join("origin.git");
2690 let repo = dir.path().join("repo");
2691 let o = origin.to_string_lossy().into_owned();
2692 git::git(dir.path(), &["init", "--bare", "-b", "main", &o])
2693 .await
2694 .unwrap();
2695 tokio::fs::create_dir_all(&repo).await.unwrap();
2696 git::git(&repo, &["init", "-b", "main"]).await.unwrap();
2697 git::git(&repo, &["config", "user.name", "test"])
2698 .await
2699 .unwrap();
2700 git::git(&repo, &["config", "user.email", "test@example.com"])
2701 .await
2702 .unwrap();
2703 for (name, body) in files {
2704 tokio::fs::write(repo.join(name), body).await.unwrap();
2705 }
2706 git::git(&repo, &["add", "-A"]).await.unwrap();
2707 git::git(&repo, &["commit", "-m", "init"]).await.unwrap();
2708 git::git(&repo, &["remote", "add", "origin", &o])
2709 .await
2710 .unwrap();
2711 git::git(&repo, &["push", "origin", "main"]).await.unwrap();
2712 (dir, repo)
2713 }
2714
2715 async fn no_pr(_: String) -> Result<bool> {
2716 Ok(false)
2717 }
2718
2719 async fn with_branch(ahead: bool) -> (tempfile::TempDir, PathBuf) {
2722 let (d, repo) = origin_with(&[("f", "x\n")]).await;
2723 git::git(&repo, &["branch", "b"]).await.unwrap();
2724 if ahead {
2725 git::git(&repo, &["checkout", "-q", "b"]).await.unwrap();
2726 git::git(&repo, &["commit", "--allow-empty", "-m", "wip"])
2727 .await
2728 .unwrap();
2729 git::git(&repo, &["checkout", "-q", "main"]).await.unwrap();
2730 }
2731 (d, repo)
2732 }
2733
2734 async fn attempt(repo: &Path, open_pr: bool, fail_after_push: Option<bool>) -> Result<()> {
2735 let wt = repo.parent().unwrap().join("bump");
2736 release_attempt(
2737 repo,
2738 "origin",
2739 "main",
2740 &wt,
2741 "b",
2742 |_| async move { Ok(open_pr) },
2743 |w| async move {
2744 if fail_after_push == Some(true) {
2745 git::push(&w, "origin", "b").await?;
2746 }
2747 if fail_after_push.is_some() {
2748 bail!("cargo build failed");
2749 }
2750 Ok(())
2751 },
2752 )
2753 .await
2754 }
2755
2756 #[tokio::test]
2757 async fn a_stale_ancestor_branch_is_deleted_and_the_attempt_proceeds() {
2758 let (_d, repo) = with_branch(false).await;
2759 attempt(&repo, false, None).await.unwrap();
2760 assert!(git::branch_exists(&repo, "b").await.unwrap());
2762 }
2763
2764 #[tokio::test]
2765 async fn a_stale_branch_holding_a_leftover_worktree_is_reclaimed() {
2766 let (_d, repo) = with_branch(false).await;
2767 let old = repo.parent().unwrap().join("old");
2768 git::git(&repo, &["worktree", "add", &old.to_string_lossy(), "b"])
2769 .await
2770 .unwrap();
2771 attempt(&repo, false, None).await.unwrap();
2772 assert!(!old.exists());
2773 }
2774
2775 #[tokio::test]
2776 async fn a_stale_branch_with_an_unmerged_commit_is_kept_with_a_reason() {
2777 let (_d, repo) = with_branch(true).await;
2778 let e = attempt(&repo, false, None).await.unwrap_err().to_string();
2779 assert!(e.contains("`b`") || e.contains("branch b"), "{e}");
2780 assert!(e.contains("1 commit(s) not in origin/main"), "{e}");
2781 assert!(git::branch_exists(&repo, "b").await.unwrap());
2782 }
2783
2784 #[tokio::test]
2785 async fn a_stale_branch_on_the_remote_is_kept() {
2786 let (_d, repo) = with_branch(false).await;
2787 git::git(&repo, &["push", "origin", "b"]).await.unwrap();
2788 let e = attempt(&repo, false, None).await.unwrap_err().to_string();
2789 assert!(e.contains("branch b") && e.contains("is on origin"), "{e}");
2790 assert!(git::branch_exists(&repo, "b").await.unwrap());
2791 }
2792
2793 #[tokio::test]
2794 async fn a_stale_branch_with_an_open_pull_request_is_kept() {
2795 let (_d, repo) = with_branch(false).await;
2796 let e = attempt(&repo, true, None).await.unwrap_err().to_string();
2797 assert!(e.contains("open pull request"), "{e}");
2798 assert!(git::branch_exists(&repo, "b").await.unwrap());
2799 }
2800
2801 #[tokio::test]
2802 async fn an_unanswerable_pull_request_check_keeps_the_branch() {
2803 let (_d, repo) = with_branch(false).await;
2804 let wt = repo.parent().unwrap().join("bump");
2805 let e = release_attempt(
2806 &repo,
2807 "origin",
2808 "main",
2809 &wt,
2810 "b",
2811 |_| async { bail!("offline") },
2812 |_| async { Ok(()) },
2813 )
2814 .await
2815 .unwrap_err()
2816 .to_string();
2817 assert!(
2818 e.contains("could not check for an open pull request"),
2819 "{e}"
2820 );
2821 assert!(git::branch_exists(&repo, "b").await.unwrap());
2822 }
2823
2824 #[tokio::test]
2825 async fn a_failed_attempt_removes_its_own_worktree_and_branch() {
2826 let (_d, repo) = origin_with(&[("f", "x\n")]).await;
2827 let wt = repo.parent().unwrap().join("bump");
2828 let e = attempt(&repo, false, Some(false)).await.unwrap_err();
2829 assert!(format!("{e:#}").contains("cargo build failed"));
2830 assert!(!wt.exists());
2831 assert!(!git::branch_exists(&repo, "b").await.unwrap());
2832 }
2833
2834 #[tokio::test]
2835 async fn release_worktrees_accept_canonical_paths_from_a_detached_checkout() {
2836 let (dir, repo) = origin_with(&[("f", "remote base\n")]).await;
2837 let base = git::rev_parse(&repo, "origin/main").await.unwrap();
2838 tokio::fs::write(repo.join("f"), "local only\n")
2840 .await
2841 .unwrap();
2842 git::git(&repo, &["commit", "-am", "local only"])
2843 .await
2844 .unwrap();
2845 git::git(&repo, &["checkout", "--detach"]).await.unwrap();
2846 let root = std::fs::canonicalize(dir.path()).unwrap();
2849 let worktree = root.join("release bump");
2850 let head = release_attempt(
2851 &repo,
2852 "origin",
2853 "main",
2854 &worktree,
2855 "release-test",
2856 no_pr,
2857 |path| async move {
2858 assert_eq!(
2861 tokio::fs::read_to_string(path.join("f"))
2862 .await
2863 .unwrap()
2864 .replace("\r\n", "\n"),
2865 "remote base\n"
2866 );
2867 git::rev_parse(&path, "HEAD").await
2868 },
2869 )
2870 .await
2871 .unwrap();
2872 assert_eq!(head, base);
2873 assert!(!worktree.exists());
2874
2875 git::worktree_add_existing(&repo, &worktree, "release-test", true)
2877 .await
2878 .unwrap();
2879 assert_eq!(git::rev_parse(&worktree, "HEAD").await.unwrap(), base);
2880 assert_eq!(
2881 tokio::fs::read_to_string(worktree.join("f"))
2882 .await
2883 .unwrap()
2884 .replace("\r\n", "\n"),
2885 "remote base\n"
2886 );
2887 git::worktree_remove(&repo, &worktree).await.unwrap();
2888 git::branch_delete(&repo, "release-test").await.unwrap();
2889
2890 git::worktree_add_branch(&repo, &worktree, "fresh-test", "origin/main")
2891 .await
2892 .unwrap();
2893 assert_eq!(git::rev_parse(&worktree, "HEAD").await.unwrap(), base);
2894 git::worktree_remove(&repo, &worktree).await.unwrap();
2895 git::branch_delete(&repo, "fresh-test").await.unwrap();
2896 assert!(!worktree.exists());
2897 }
2898
2899 #[tokio::test]
2900 async fn a_pushed_branch_survives_a_failed_attempt_and_the_reason_says_so() {
2901 let (_d, repo) = origin_with(&[("f", "x\n")]).await;
2902 let e = attempt(&repo, false, Some(true)).await.unwrap_err();
2903 let e = format!("{e:#}");
2904 assert!(
2905 e.contains("cargo build failed") && e.contains("pushed to origin"),
2906 "{e}"
2907 );
2908 assert!(git::branch_exists(&repo, "b").await.unwrap());
2909 }
2910
2911 #[tokio::test]
2912 async fn a_branch_left_by_a_half_done_worktree_add_is_removed() {
2913 let (_d, repo) = origin_with(&[("f", "x\n")]).await;
2916 let blocker = repo.parent().unwrap().join("blocker");
2917 tokio::fs::write(&blocker, "file").await.unwrap();
2918 let wt = blocker.join("bump");
2919 let r = release_attempt(
2920 &repo,
2921 "origin",
2922 "main",
2923 &wt,
2924 "b",
2925 |_| async { bail!("offline") },
2926 |_| async { Ok(()) },
2927 )
2928 .await;
2929 assert!(r.is_err());
2930 assert!(!git::branch_exists(&repo, "b").await.unwrap());
2931 }
2932
2933 #[tokio::test]
2934 async fn the_retry_is_taken_at_most_once() {
2935 let (_d, repo) = with_branch(false).await;
2938 let blocker = repo.parent().unwrap().join("blocker");
2939 tokio::fs::write(&blocker, "file").await.unwrap();
2940 let wt = blocker.join("bump");
2941 let r = release_attempt(&repo, "origin", "main", &wt, "b", no_pr, |_| async {
2942 Ok(())
2943 })
2944 .await;
2945 assert!(r.is_err());
2946 assert!(!git::branch_exists(&repo, "b").await.unwrap());
2947 }
2948
2949 #[tokio::test]
2950 async fn release_worktree_failure_preserves_full_diagnostics_and_operator_data() {
2951 let (dir, repo) = origin_with(&[("f", "x\n")]).await;
2952 let worktree = dir.path().join("occupied");
2953 tokio::fs::create_dir(&worktree).await.unwrap();
2954 let existing = worktree.join("keep");
2955 tokio::fs::write(&existing, "operator data").await.unwrap();
2956 let err = release_attempt::<(), _, _, _, _>(
2957 &repo,
2958 "origin",
2959 "main",
2960 &worktree,
2961 "release-test",
2962 no_pr,
2963 |_| async { panic!("worktree creation must fail before release edits") },
2964 )
2965 .await
2966 .unwrap_err();
2967 let (version, reason) = notice_for_failure(&Progress::default(), &err);
2968 assert!(
2969 reason.contains("create the release-bump worktree"),
2970 "{reason}"
2971 );
2972 assert!(reason.contains("exit code 128"), "{reason}");
2973 assert!(reason.contains("Preparing worktree"), "{reason}");
2974 assert!(reason.contains("\nfatal:"), "{reason}");
2975 let store = Notices::at(dir.path().join("notifications"));
2976 let mut state = winner_state(&repo, "main");
2977 state.status = RunStatus::Merged;
2978 report_problem_in(&mut state, &store, None, version.as_deref(), &reason, false).await;
2979 let notices = store.list();
2980 assert_eq!(notices.len(), 1);
2981 let notice = ¬ices[0];
2982 assert!(notice.message.contains("fatal:"), "{}", notice.message);
2983 assert!(!notice.message.contains("Some(") && !notice.message.contains("None"));
2984 assert_eq!(notice.severity, Severity::Error);
2985 assert_eq!(state.status, RunStatus::Merged);
2986 assert!(state.needs_attention());
2987 let problem = state
2988 .release_bump
2989 .as_ref()
2990 .unwrap()
2991 .problem
2992 .as_ref()
2993 .unwrap();
2994 assert_eq!(
2995 problem,
2996 &crate::scrub::scrub(&reason, &crate::scrub::Identity::current())
2997 );
2998 let saved = serde_json::to_string(&state).unwrap();
2999 let restored: RunState = serde_json::from_str(&saved).unwrap();
3000 assert_eq!(
3001 restored.release_bump.as_ref().unwrap().problem.as_ref(),
3002 Some(problem)
3003 );
3004 assert!(crate::report::run(&restored).contains("fatal:"));
3005 assert!(!git::branch_exists(&repo, "release-test").await.unwrap());
3006 assert_eq!(
3007 tokio::fs::read_to_string(existing).await.unwrap(),
3008 "operator data"
3009 );
3010 }
3011
3012 #[tokio::test]
3013 async fn base_has_cargo_toml_tells_rust_from_non_rust() {
3014 let (_d, rust) = origin_with(&[("Cargo.toml", "[package]\nversion = \"0.1.0\"\n")]).await;
3015 assert!(base_has_cargo_toml(&rust, "origin", "main").await.unwrap());
3016 let (_d2, other) = origin_with(&[("README.md", "hi\n")]).await;
3017 assert!(!base_has_cargo_toml(&other, "origin", "main").await.unwrap());
3018 assert!(base_has_cargo_toml(&other, "origin", "nope").await.is_err());
3020 }
3021
3022 #[tokio::test]
3023 async fn a_repo_without_cargo_toml_skips_with_one_event_and_no_lock() {
3024 let (_d, repo) = origin_with(&[("README.md", "hi\n")]).await;
3025 let home = tempfile::tempdir().unwrap();
3026 let mut state = RunState::new(
3027 repo.clone(),
3028 "main".to_owned(),
3029 "0000000000000000000000000000000000000000".to_owned(),
3030 "task".to_owned(),
3031 Config::default(),
3032 );
3033 state.candidates.push(crate::run::Candidate {
3034 index: 0,
3035 label: 'A',
3036 agent: "x".to_owned(),
3037 branch: "main".to_owned(),
3038 worktree: repo.clone(),
3039 summary: String::new(),
3040 stat: String::new(),
3041 files: 1,
3042 commits: 1,
3043 empty: false,
3044 failed: None,
3045 verified_noop: None,
3046 duration_ms: 0,
3047 folded: false,
3048 });
3049 state.tally = Some(
3050 serde_json::from_value(serde_json::json!({
3051 "first_choice": {}, "borda": {}, "winner": "A",
3052 "unanimous_initial": true, "deliberated": false,
3053 "changed_votes": 0, "unanimous_final": true,
3054 }))
3055 .unwrap(),
3056 );
3057 after_merge_at(
3058 &mut state,
3059 "https://example.invalid/pull/1",
3060 Some(home.path()),
3061 None,
3062 )
3063 .await
3064 .expect("a non-Rust repository is not an error");
3065 let bumps: Vec<_> = state.events.iter().filter(|e| e.node == "bump").collect();
3066 assert_eq!(bumps.len(), 1, "{:?}", state.events);
3067 assert_eq!(
3068 bumps[0].message,
3069 "release bump: no Cargo.toml on the base branch; release bumps are Rust-only, skipping"
3070 );
3071 assert!(
3072 std::fs::read_dir(home.path()).unwrap().next().is_none(),
3073 "no marker and no lock may be created"
3074 );
3075 }
3076
3077 fn winner_state(repo: &Path, base: &str) -> RunState {
3078 let mut state = RunState::new(
3079 repo.to_path_buf(),
3080 base.to_owned(),
3081 "0000000000000000000000000000000000000000".to_owned(),
3082 "task".to_owned(),
3083 Config::default(),
3084 );
3085 state.candidates.push(crate::run::Candidate {
3086 index: 0,
3087 label: 'A',
3088 agent: "x".to_owned(),
3089 branch: "main".to_owned(),
3090 worktree: repo.to_path_buf(),
3091 summary: String::new(),
3092 stat: String::new(),
3093 files: 1,
3094 commits: 1,
3095 empty: false,
3096 failed: None,
3097 verified_noop: None,
3098 duration_ms: 0,
3099 folded: false,
3100 });
3101 state.tally = Some(
3102 serde_json::from_value(serde_json::json!({
3103 "first_choice": {}, "borda": {}, "winner": "A",
3104 "unanimous_initial": true, "deliberated": false,
3105 "changed_votes": 0, "unanimous_final": true,
3106 }))
3107 .unwrap(),
3108 );
3109 state
3110 }
3111
3112 #[tokio::test]
3113 async fn a_real_failure_without_a_pr_raises_one_notice_and_a_retry_folds_into_it() {
3114 let (_d, repo) =
3115 origin_with(&[("Cargo.toml", "[package]\nname=\"x\"\nversion=\"0.1.0\"\n")]).await;
3116 let home = tempfile::tempdir().unwrap();
3117 let store = Notices::at(home.path().join("notifications"));
3118 let mut state = winner_state(&repo, "nope");
3120 let url = "https://example.invalid/pull/1";
3121 after_merge_at(&mut state, url, Some(home.path()), Some(&store))
3122 .await
3123 .expect_err("an unresolvable base is a failure");
3124 let listed = store.list();
3125 assert_eq!(listed.len(), 1, "{listed:?}");
3126 assert!(state.events.iter().any(|e| e.node == "bump"));
3127 after_merge_at(&mut state, url, Some(home.path()), Some(&store))
3128 .await
3129 .expect_err("still failing");
3130 let listed = store.list();
3131 assert_eq!(listed.len(), 1, "{listed:?}");
3132 assert_eq!(listed[0].count, 2);
3133 }
3134
3135 #[tokio::test]
3136 async fn not_eligible_cases_raise_no_notice() {
3137 let home = tempfile::tempdir().unwrap();
3138 let store = Notices::at(home.path().join("notifications"));
3139 let url = "https://example.invalid/pull/1";
3140 let (_d, repo) = origin_with(&[("README.md", "hi\n")]).await;
3142 let mut state = winner_state(&repo, "main");
3143 after_merge_at(&mut state, url, Some(home.path()), Some(&store))
3144 .await
3145 .unwrap();
3146 let mut state = winner_state(&repo, "nope");
3148 state.config.merge.release_bump = false;
3149 after_merge_at(&mut state, url, Some(home.path()), Some(&store))
3150 .await
3151 .unwrap();
3152 let mut state = winner_state(&repo, "nope");
3154 state.tally = None;
3155 after_merge_at(&mut state, url, Some(home.path()), Some(&store))
3156 .await
3157 .unwrap();
3158 assert!(store.list().is_empty(), "{:?}", store.list());
3159 }
3160
3161 #[test]
3162 fn the_no_pr_notice_follows_the_configured_language() {
3163 let dir = tempfile::tempdir().unwrap();
3164 let store = Notices::at(dir.path().join("notifications"));
3165 let mut state = merged_state();
3166 state.config.graph.language = "ja".to_owned();
3167 let (n, _) = surface_problem(&mut state, &store, None, Some("0.2.0"), "boom").unwrap();
3168 assert!(n.message.contains("実行されませんでした"), "{}", n.message);
3169 assert!(n.message.contains("boom") && n.message.contains("v0.2.0"));
3170 }
3171
3172 #[test]
3173 fn a_failed_escalation_points_at_the_pending_pr_without_commenting() {
3174 let dir = tempfile::tempdir().unwrap();
3175 let store = Notices::at(dir.path().join("notifications"));
3176 let mut state = merged_state();
3177 let url = "https://example.invalid/pull/9";
3178 let (n, comment) = surface_problem_in(
3179 &mut state,
3180 &store,
3181 Some(url),
3182 Some("0.3.0"),
3183 "push failed",
3184 true,
3185 )
3186 .unwrap();
3187 assert!(comment.is_none());
3188 assert!(
3189 n.message.contains(url) && n.message.contains("v0.3.0"),
3190 "{}",
3191 n.message
3192 );
3193 assert!(!n.message.contains("open the release pull request by hand"));
3194 assert!(matches!(n.link, Some(Link::Url { .. })));
3195 }
3196
3197 #[test]
3198 fn a_failure_notice_preserves_the_full_error_chain() {
3199 let err = anyhow!("outer context").context("cargo build failed\nsecond line");
3200 let with_pr = Progress {
3201 version: Some("0.2.0".into()),
3202 pending_pr: Some("https://example.invalid/pull/9".into()),
3203 skip: None,
3204 };
3205 let (v, reason) = notice_for_failure(&with_pr, &err);
3206 assert_eq!(v.as_deref(), Some("0.2.0"));
3207 assert_eq!(reason, "cargo build failed\nsecond line: outer context");
3208 let (v, reason) = notice_for_failure(&Progress::default(), &err);
3209 assert_eq!(v, None);
3210 assert_eq!(reason, "cargo build failed\nsecond line: outer context");
3211 }
3212
3213 #[test]
3214 fn failure_headline_prefers_git_errors_and_skips_blank_lines() {
3215 assert_eq!(
3216 failure_headline("checkout failed\nPreparing worktree\n fatal: invalid path\n"),
3217 Some("fatal: invalid path")
3218 );
3219 assert_eq!(
3220 failure_headline("Preparing worktree\n error: checkout failed\n"),
3221 Some("error: checkout failed")
3222 );
3223 assert_eq!(
3224 failure_headline("\n \n first cause \nsecond"),
3225 Some("first cause")
3226 );
3227 assert_eq!(failure_headline(" \n\t"), None);
3228 }
3229
3230 const NO_RULES: &str = "gh pr merge --auto: GraphQL: Pull request Branch does not have \
3231 required protected branch rules (enablePullRequestAutoMerge)";
3232
3233 fn merged_state() -> RunState {
3234 run::pin_test_home();
3237 let mut s = RunState::new(
3238 PathBuf::from("/no/such/repo"),
3239 "main".to_owned(),
3240 "0000000000000000000000000000000000000000".to_owned(),
3241 "task".to_owned(),
3242 Config::default(),
3243 );
3244 s.status = RunStatus::Merged;
3245 s
3246 }
3247
3248 #[cfg(unix)]
3249 fn decision_cli(id: &str, reply: &str, exit: &str) -> AgentSpec {
3250 AgentSpec {
3251 id: id.into(),
3252 kind: crate::config::AgentKind::Command,
3253 model: None,
3254 command: vec![
3255 "sh".into(),
3256 "-c".into(),
3257 concat!(
3258 "if [ \"$STATUS\" = timeout ]; then exec sleep 5; fi; ",
3259 "printf '%s' \"$REPLY\"; exit \"$STATUS\""
3260 )
3261 .into(),
3262 ],
3263 extra_args: Vec::new(),
3264 env: std::collections::BTreeMap::from([
3265 ("REPLY".into(), reply.into()),
3266 ("STATUS".into(), exit.into()),
3267 ]),
3268 prompt_delivery: None,
3269 max_turn_secs: None,
3270 }
3271 }
3272
3273 #[cfg(unix)]
3274 fn decision_state(agents: Vec<AgentSpec>, preferences: &[&str]) -> RunState {
3275 let mut state = merged_state();
3276 state.config.agents = agents;
3277 state.config.roles.chatter = Some(crate::config::AgentChoice::Chain(
3278 preferences.iter().map(|s| (*s).to_owned()).collect(),
3279 ));
3280 state
3281 }
3282
3283 #[cfg(unix)]
3284 const VALID_DECISION: &str = r#"{"level":"minor","reason":"Adds a feature."}"#;
3285
3286 #[cfg(unix)]
3287 #[tokio::test]
3288 async fn decision_failover_handles_each_unusable_cli_outcome() {
3289 for (reply, exit, expected) in [
3290 (
3291 r#"{"is_error":true,"api_error_status":429,"api_error":"usage_limit_reached"}"#,
3292 "1",
3293 "rate/quota limit",
3294 ),
3295 (
3296 r#"{"is_error":true,"api_error_status":429,"api_error":"usage_limit_reached","level":"minor","reason":"Looks valid."}"#,
3297 "0",
3298 "rate/quota limit",
3299 ),
3300 (
3301 r#"{"is_error":true,"api_error_status":"429","api_error":"usage_limit_reached","level":"minor","reason":"Looks valid."}"#,
3302 "0",
3303 "rate/quota limit",
3304 ),
3305 ("", "0", "empty output"),
3306 (
3307 "",
3308 "spawn",
3309 "CLI invocation failed; inspect attempt artifacts",
3310 ),
3311 ("not JSON", "0", "invalid decision JSON or missing reason"),
3312 (VALID_DECISION, "1", "CLI failed (exit code 1)"),
3313 ("", "timeout", "timed out"),
3314 ] {
3315 let dir = tempfile::tempdir().unwrap();
3316 let mut state = decision_state(
3317 vec![
3318 decision_cli("first", reply, exit),
3319 decision_cli("second", VALID_DECISION, "0"),
3320 ],
3321 &["first", "second"],
3322 );
3323 if exit == "spawn" {
3324 state.config.agents[0].command = vec!["magi-test-no-such-decision-cli".into()];
3325 }
3326 let (spec, seat, decision) =
3327 ask_decision(&mut state, dir.path(), "decide", Duration::from_millis(200))
3328 .await
3329 .unwrap();
3330 assert_eq!(spec.id, "second");
3331 assert_eq!(decision.level, BumpLevel::Minor);
3332 assert_eq!(state.bump_decision_attempts.len(), 2);
3333 assert_eq!(state.bump_decision_attempts[0].outcome, expected);
3334 assert_eq!(state.handovers.len(), 1);
3335 assert_eq!(state.handovers[0].to, "second");
3336 assert_ne!(
3337 seat.claude_session,
3338 SeatState::new("bump", "first", state.seed).claude_session
3339 );
3340 let report = crate::report::run(&state);
3341 assert!(report.contains(expected), "{report}");
3342 assert!(report.contains("second: valid decision"), "{report}");
3343 assert!(state.release_bump.is_none());
3344 let artifacts = agent::artifacts_dir(&state.dir());
3345 if exit != "spawn" {
3346 assert!(artifacts.join("bump-decision-1.out").exists());
3347 }
3348 assert!(artifacts.join("bump-decision-2.out").exists());
3349 }
3350 }
3351
3352 #[cfg(unix)]
3353 #[tokio::test]
3354 async fn decision_chain_respects_preferences_and_stops_on_first_success() {
3355 let dir = tempfile::tempdir().unwrap();
3356 let mut state = decision_state(
3357 vec![
3358 decision_cli("first", "bad", "1"),
3359 decision_cli("second", VALID_DECISION, "0"),
3360 ],
3361 &["missing", "second", "second", "first"],
3362 );
3363 let (spec, _, _) = ask_decision(&mut state, dir.path(), "decide", Duration::from_secs(1))
3364 .await
3365 .unwrap();
3366 assert_eq!(spec.id, "second");
3367 assert_eq!(state.bump_decision_attempts.len(), 1);
3368 assert!(state.handovers.is_empty());
3369 }
3370
3371 #[cfg(unix)]
3372 #[tokio::test]
3373 async fn decision_chain_consumes_same_failure_classes_and_preserves_unset_policy() {
3374 let dir = tempfile::tempdir().unwrap();
3375 let mut state = decision_state(
3376 vec![
3377 decision_cli("first", "bad", "0"),
3378 decision_cli("second", "bad", "0"),
3379 decision_cli("third", VALID_DECISION, "0"),
3380 ],
3381 &["first", "second", "third"],
3382 );
3383 let (spec, _, _) = ask_decision(&mut state, dir.path(), "decide", Duration::from_secs(2))
3384 .await
3385 .unwrap();
3386 assert_eq!(spec.id, "third");
3387 assert_eq!(state.bump_decision_attempts.len(), 3);
3388 assert_eq!(state.handovers.len(), 2);
3389 state.config.roles.chatter = None;
3391 let err = ask_decision(&mut state, dir.path(), "decide", Duration::from_secs(2))
3392 .await
3393 .unwrap_err();
3394 assert!(err.to_string().contains("exhausted 1 eligible agent(s)"));
3395 assert_eq!(state.bump_decision_attempts.len(), 4);
3396 }
3397
3398 #[cfg(unix)]
3399 #[tokio::test]
3400 async fn decision_reason_rewrite_failure_preserves_the_selected_level() {
3401 let dir = tempfile::tempdir().unwrap();
3402 for reply in ["invalid", r#"{"level":"patch","reason":"Fixes a defect."}"#] {
3403 let mut state = merged_state();
3404 state.config.graph.github_text_guard = true;
3405 state.config.graph.github_language = "en".into();
3406 let spec = decision_cli("chosen", reply, "0");
3407 let mut seat = SeatState::new("bump", &spec.id, state.seed);
3408 let mut decision =
3409 parse_decision(r#"{"level":"minor","reason":"新しい機能を追加しました。"}"#)
3410 .unwrap();
3411 guard_reason(
3412 &mut state,
3413 dir.path(),
3414 "decide",
3415 &spec,
3416 &mut seat,
3417 &mut decision,
3418 )
3419 .await;
3420 assert_eq!(decision.level, BumpLevel::Minor);
3421 assert_eq!(decision.reason, "The merged change requires a release.");
3422 assert!(state.handovers.is_empty());
3423 assert!(state.bump_decision_attempts.is_empty());
3424 }
3425 }
3426
3427 #[cfg(unix)]
3428 #[tokio::test]
3429 async fn decision_exhaustion_is_bounded_reported_and_leaves_no_release_outcome() {
3430 let dir = tempfile::tempdir().unwrap();
3431 let mut state = decision_state(
3432 vec![
3433 decision_cli("first", "bad", "0"),
3434 decision_cli("second", "", "0"),
3435 ],
3436 &["first", "first", "second", "second"],
3437 );
3438 let err = ask_decision(&mut state, dir.path(), "decide", Duration::from_secs(1))
3439 .await
3440 .unwrap_err()
3441 .to_string();
3442 assert!(err.contains("exhausted 2 eligible agent(s)"), "{err}");
3443 assert!(err.contains("first: invalid decision JSON"), "{err}");
3444 assert!(err.contains("second: empty output"), "{err}");
3445 assert!(err.contains("[roles] chatter"), "{err}");
3446 assert_eq!(state.bump_decision_attempts.len(), 2);
3447 assert_eq!(state.handovers.len(), 1);
3448 assert!(state.release_bump.is_none());
3449 let report = crate::report::run(&state);
3450 assert!(report.contains("first: invalid decision JSON"));
3451 assert!(report.contains("second: empty output"));
3452 let restored: RunState =
3453 serde_json::from_slice(&serde_json::to_vec(&state).unwrap()).unwrap();
3454 assert_eq!(restored.bump_decision_attempts.len(), 2);
3455 }
3456
3457 #[test]
3458 fn the_known_automerge_refusal_names_branch_protection() {
3459 assert!(automerge_hint(NO_RULES).contains("branch protection with required"));
3460 let other = automerge_hint("gh: network unreachable");
3461 assert!(!other.contains("branch protection"), "{other}");
3462 let body = automerge_failure_comment(NO_RULES);
3463 assert!(body.contains("enablePullRequestAutoMerge"), "{body}");
3464 assert!(body.contains("Action required"), "{body}");
3465 }
3466
3467 const CLEAN: &str = "gh pr merge --auto: GraphQL: Pull request Pull request is in clean \
3468 status (enablePullRequestAutoMerge)";
3469
3470 #[test]
3471 fn clean_status_refusal_is_matched_narrowly() {
3472 assert!(is_clean_status_refusal(CLEAN));
3473 assert!(!is_clean_status_refusal(NO_RULES));
3474 assert!(!is_clean_status_refusal("gh: network unreachable"));
3475 assert!(!is_clean_status_refusal("Pull request is in clean status"));
3476 assert!(automerge_hint(CLEAN).contains("already green"));
3477 }
3478
3479 #[test]
3480 fn the_direct_merge_argv_matches_the_land_flags() {
3481 let a = bump_merge_argv("https://github.com/o/r/pull/9", "chore: release v1.0.0");
3482 let l = land::merge_argv(9, "chore: release v1.0.0");
3483 assert_eq!(a[..2], l[..2]);
3484 assert_eq!(a[3..], l[3..]);
3485 assert_eq!(a[2], "https://github.com/o/r/pull/9");
3486 }
3487
3488 #[test]
3489 fn a_direct_merge_is_judged_by_the_forge_not_the_exit_code() {
3490 let argv = bump_merge_argv("u", "t");
3491 let merged = |o: &AutomergeOutcome| matches!(o, AutomergeOutcome::MergedDirectly { .. });
3492 assert!(merged(&resolve_direct_merge(CLEAN, &argv, true, "", None)));
3493 let detached = "not on any branch";
3494 assert!(merged(&resolve_direct_merge(
3495 CLEAN,
3496 &argv,
3497 false,
3498 detached,
3499 Some(PrLifecycle::Merged)
3500 )));
3501 for after in [Some(PrLifecycle::Open), None] {
3502 let o = resolve_direct_merge(CLEAN, &argv, false, "boom", after);
3503 match o {
3504 AutomergeOutcome::Failed { reason } => {
3505 assert!(
3506 reason.contains("clean status") && reason.contains("boom"),
3507 "{reason}"
3508 )
3509 }
3510 other => panic!("expected Failed, got {other:?}"),
3511 }
3512 }
3513 }
3514
3515 #[test]
3516 fn a_local_mode_bump_reads_back_and_old_records_are_not_local() {
3517 let old: run::ReleaseBump =
3518 serde_json::from_str(r#"{"pr_url":"u","automerge_enabled":true}"#).unwrap();
3519 assert!(!old.local);
3520 let mut state = merged_state();
3521 state.release_bump = Some(run::ReleaseBump {
3522 pr_url: Some("https://github.com/o/r/pull/9".to_owned()),
3523 version: Some("1.0.0".to_owned()),
3524 local: true,
3525 ..run::ReleaseBump::default()
3526 });
3527 assert!(!state.needs_attention());
3529 let text = crate::report::run(&state);
3530 assert!(text.contains("release.mode = local"), "{text}");
3531 assert!(!text.contains("FAILED"), "{text}");
3532 }
3533
3534 #[test]
3535 fn a_directly_merged_bump_is_not_reported_as_pending_or_failed() {
3536 let mut state = merged_state();
3537 state.release_bump = Some(run::ReleaseBump {
3538 pr_url: Some("https://github.com/o/r/pull/9".to_owned()),
3539 version: Some("1.0.0".to_owned()),
3540 merged_directly: true,
3541 ..run::ReleaseBump::default()
3542 });
3543 assert!(!state.needs_attention());
3544 let text = crate::report::run(&state);
3545 assert!(text.contains("merged directly"), "{text}");
3546 assert!(!text.contains("FAILED"), "{text}");
3547 }
3548
3549 #[test]
3550 fn an_automerge_failure_is_recorded_shown_and_filed_and_survives_settling() {
3551 let dir = tempfile::tempdir().unwrap();
3552 let store = Notices::at(dir.path().join("notifications"));
3553 let questions = ask::Questions::at(dir.path().join("questions"));
3554 let mut state = merged_state();
3555 let url = "https://github.com/o/r/pull/35";
3556
3557 let (n, comment) =
3558 surface_problem(&mut state, &store, Some(url), Some("0.8.0"), NO_RULES).unwrap();
3559
3560 let comment = comment.expect("a PR was opened, so it gets a comment");
3562 assert!(comment.contains("branch protection"), "{comment}");
3563
3564 assert_eq!(state.status, RunStatus::Merged);
3566 assert!(state.needs_attention());
3567 let text = crate::report::run(&state);
3568 assert!(text.contains("release bump"), "{text}");
3569 assert!(text.contains("FAILED"), "{text}");
3570 assert!(text.contains(url), "{text}");
3571 assert!(text.contains("action required"), "{text}");
3572 assert!(crate::report::line(&state).contains("release needs a human"));
3573
3574 assert_eq!(n.severity, Severity::Error);
3576 assert_eq!(
3577 n.link,
3578 Some(Link::Url {
3579 url: url.to_owned()
3580 })
3581 );
3582 assert_eq!(store.list().len(), 1);
3583 assert!(questions.open_for(&state.id).is_empty());
3584
3585 surface_problem(&mut state, &store, Some(url), Some("0.8.0"), NO_RULES).unwrap();
3587 let listed = store.list();
3588 assert_eq!(listed.len(), 1);
3589 assert_eq!(listed[0].count, 2);
3590 }
3591
3592 #[test]
3593 fn a_bump_that_never_ran_is_surfaced_without_a_pr_comment() {
3594 let dir = tempfile::tempdir().unwrap();
3595 let store = Notices::at(dir.path().join("notifications"));
3596 let mut state = merged_state();
3597 let (n, comment) = surface_problem(&mut state, &store, None, None, "no agent").unwrap();
3598 assert!(comment.is_none());
3599 assert!(matches!(n.link, Some(Link::Run { .. })));
3600 assert!(state.needs_attention());
3601 }
3602
3603 #[test]
3604 fn version_parses_and_bumps_each_digit() {
3605 let v = Version::parse("0.4.0").unwrap();
3606 assert_eq!(
3607 v,
3608 Version {
3609 major: 0,
3610 minor: 4,
3611 patch: 0
3612 }
3613 );
3614
3615 assert_eq!(v.bump(BumpLevel::Major).to_string(), "1.0.0");
3616 assert_eq!(v.bump(BumpLevel::Minor).to_string(), "0.5.0");
3617 assert_eq!(v.bump(BumpLevel::Patch).to_string(), "0.4.1");
3618 }
3619
3620 #[test]
3621 fn version_tolerates_a_prerelease_suffix_on_patch() {
3622 let v = Version::parse("1.2.3-rc1").unwrap();
3623 assert_eq!(
3624 v,
3625 Version {
3626 major: 1,
3627 minor: 2,
3628 patch: 3
3629 }
3630 );
3631 }
3632
3633 #[test]
3634 fn version_rejects_garbage() {
3635 assert!(Version::parse("not-a-version").is_err());
3636 assert!(Version::parse("1.2").is_err());
3637 }
3638
3639 #[test]
3640 fn decision_parses_each_level() {
3641 for (json, level) in [
3642 (
3643 r#"{"level":"major","reason":"drops a config key"}"#,
3644 BumpLevel::Major,
3645 ),
3646 (
3647 r#"{"level":"minor","reason":"adds a new flag"}"#,
3648 BumpLevel::Minor,
3649 ),
3650 (
3651 r#"{"level":"patch","reason":"fixes a race"}"#,
3652 BumpLevel::Patch,
3653 ),
3654 ] {
3655 let decision = parse_decision(json).unwrap();
3656 assert_eq!(decision.level, level);
3657 assert!(!decision.reason.is_empty());
3658 }
3659 }
3660
3661 #[test]
3662 fn decision_wrapped_in_a_fence_and_prose_still_parses() {
3663 let text = "Here is my call.\n\n```json\n{\"level\":\"minor\",\"reason\":\"new HTTP route\"}\n```\n\nDone.";
3664 let decision = parse_decision(text).unwrap();
3665 assert_eq!(decision.level, BumpLevel::Minor);
3666 assert_eq!(decision.reason, "new HTTP route");
3667 }
3668
3669 #[test]
3670 fn a_broken_reply_is_an_error_not_a_default() {
3671 assert!(parse_decision("I decline to answer.").is_err());
3672 assert!(parse_decision(r#"{"level":"huge","reason":"go big"}"#).is_err());
3673 assert!(
3674 parse_decision(r#"{"level":"patch","reason":""}"#).is_err(),
3675 "an empty reason must not pass either"
3676 );
3677 assert!(
3678 parse_decision(r#"{"level":"patch"}"#).is_err(),
3679 "a reply with no reason at all must not pass"
3680 );
3681 }
3682
3683 #[test]
3684 fn prompt_states_the_zero_x_rule_and_the_tie_break() {
3685 let prompt = decision_prompt(
3686 "feat: add a phone endpoint",
3687 "add POST /api/widgets",
3688 "1 file changed, 10 insertions(+)",
3689 &["src/web.rs".to_owned()],
3690 "0.8.0",
3691 );
3692 assert!(prompt.contains("0.8.0"), "the current version is stated");
3693 assert!(
3694 prompt.contains("below `1.0.0`")
3695 && prompt.contains("`minor` is the digit that carries a breaking change"),
3696 "the 0.x rule must be explicit: {prompt}"
3697 );
3698 assert!(
3699 prompt.contains("choose the larger"),
3700 "the tie-break toward the bigger digit must be explicit: {prompt}"
3701 );
3702 }
3703
3704 #[test]
3705 fn release_only_diffs_are_recognised() {
3706 assert!(is_release_only(&["Cargo.toml".to_owned()]));
3707 assert!(is_release_only(&[
3708 "Cargo.toml".to_owned(),
3709 "Cargo.lock".to_owned()
3710 ]));
3711 assert!(!is_release_only(&[]));
3712 assert!(!is_release_only(&[
3713 "Cargo.toml".to_owned(),
3714 "src/main.rs".to_owned()
3715 ]));
3716 }
3717
3718 #[test]
3719 fn cargo_version_rewrite_touches_only_the_package_table() {
3720 let toml = "\
3721[package]\n\
3722# a comment mentioning version on purpose\n\
3723name = \"magi-cli\"\n\
3724version = \"0.8.0\"\n\
3725edition = \"2024\"\n\
3726\n\
3727[dependencies]\n\
3728foo = { version = \"1.2.3\" }\n";
3729 let out = rewrite_cargo_version(toml, "0.9.0").unwrap();
3730 assert!(out.contains("version = \"0.9.0\""));
3731 assert!(
3732 out.contains("foo = { version = \"1.2.3\" }"),
3733 "a dependency's own version pin must survive: {out}"
3734 );
3735 assert!(
3736 out.contains("# a comment mentioning version on purpose"),
3737 "unrelated lines, comments included, must be byte-for-byte preserved: {out}"
3738 );
3739 assert_eq!(
3740 out.lines().count(),
3741 toml.lines().count(),
3742 "the rewrite replaces one line, it does not add or remove any"
3743 );
3744 }
3745
3746 #[test]
3747 fn cargo_version_rewrite_fails_without_a_package_table() {
3748 let toml = "[dependencies]\nfoo = \"1\"\n";
3749 assert!(rewrite_cargo_version(toml, "1.0.0").is_err());
3750 }
3751
3752 #[test]
3758 fn cargo_version_rewrite_falls_back_to_workspace_package_without_a_package_table() {
3759 let toml = "\
3760[workspace]\n\
3761members = [\"crates/a\", \"crates/b\"]\n\
3762\n\
3763[workspace.package]\n\
3764version = \"0.45.18\"\n\
3765edition = \"2024\"\n\
3766\n\
3767[workspace.dependencies]\n\
3768foo = { version = \"1.2.3\" }\n";
3769 let out = rewrite_cargo_version(toml, "0.45.19").unwrap();
3770 assert!(out.contains("version = \"0.45.19\""));
3771 assert!(
3772 out.contains("foo = { version = \"1.2.3\" }"),
3773 "a workspace dependency's own version pin must survive: {out}"
3774 );
3775 assert_eq!(
3776 out.lines().count(),
3777 toml.lines().count(),
3778 "the rewrite replaces one line, it does not add or remove any"
3779 );
3780 }
3781
3782 #[test]
3786 fn cargo_version_rewrite_bumps_an_internal_workspace_dependency_pin() {
3787 let toml = "\
3788[workspace]\n\
3789members = [\"crates/kanade-shared\"]\n\
3790\n\
3791[workspace.package]\n\
3792version = \"0.48.2\"\n\
3793\n\
3794[workspace.dependencies]\n\
3795kanade-shared = { path = \"crates/kanade-shared\", version = \"0.48.2\" }\n";
3796 let out = rewrite_cargo_version(toml, "0.48.3").unwrap();
3797 assert!(out.contains("[workspace.package]\nversion = \"0.48.3\"\n"));
3798 assert!(
3799 out.contains(
3800 "kanade-shared = { path = \"crates/kanade-shared\", version = \"0.48.3\" }"
3801 ),
3802 "the internal pin must move with the workspace version: {out}"
3803 );
3804 }
3805
3806 #[test]
3808 fn cargo_version_rewrite_bumps_an_internal_pin_with_version_before_path() {
3809 let toml = "\
3810[workspace.package]\n\
3811version = \"1.0.0\"\n\
3812\n\
3813[workspace.dependencies]\n\
3814inner = { version = \"1.0.0\", path = \"crates/inner\" }\n";
3815 let out = rewrite_cargo_version(toml, "1.0.1").unwrap();
3816 assert!(out.contains("inner = { version = \"1.0.1\", path = \"crates/inner\" }"));
3817 }
3818
3819 #[test]
3822 fn cargo_version_rewrite_bumps_an_internal_pin_in_dotted_table_form() {
3823 let toml = "\
3824[workspace.package]\n\
3825version = \"2.3.0\"\n\
3826\n\
3827[workspace.dependencies.inner]\n\
3828path = \"crates/inner\"\n\
3829version = \"2.3.0\"\n";
3830 let out = rewrite_cargo_version(toml, "2.4.0").unwrap();
3831 assert!(out.contains("[workspace.package]\nversion = \"2.4.0\"\n"));
3832 assert!(out.contains(
3833 "[workspace.dependencies.inner]\npath = \"crates/inner\"\nversion = \"2.4.0\"\n"
3834 ));
3835 }
3836
3837 #[test]
3842 fn cargo_version_rewrite_bumps_an_internal_pin_in_dotted_key_form() {
3843 let toml = "\
3844[workspace.package]\n\
3845version = \"2.3.0\"\n\
3846\n\
3847[workspace.dependencies]\n\
3848inner.path = \"crates/inner\"\n\
3849inner.version = \"2.3.0\"\n";
3850 let out = rewrite_cargo_version(toml, "2.4.0").unwrap();
3851 assert!(out.contains("[workspace.package]\nversion = \"2.4.0\"\n"));
3852 assert!(out.contains("inner.path = \"crates/inner\"\ninner.version = \"2.4.0\"\n"));
3853 }
3854
3855 #[test]
3858 fn cargo_version_rewrite_leaves_a_path_only_workspace_dependency_untouched() {
3859 let toml = "\
3860[workspace.package]\n\
3861version = \"0.1.0\"\n\
3862\n\
3863[workspace.dependencies]\n\
3864internal-only = { path = \"crates/internal-only\" }\n";
3865 let out = rewrite_cargo_version(toml, "0.2.0").unwrap();
3866 assert!(out.contains("internal-only = { path = \"crates/internal-only\" }"));
3867 }
3868
3869 #[test]
3873 fn cargo_version_rewrite_leaves_an_external_dependency_untouched() {
3874 let toml = "\
3875[workspace.package]\n\
3876version = \"0.1.0\"\n\
3877\n\
3878[workspace.dependencies]\n\
3879serde = { version = \"1\", features = [\"derive\"] }\n\
3880inner = { path = \"crates/inner\", version = \"0.1.0\" }\n";
3881 let out = rewrite_cargo_version(toml, "0.2.0").unwrap();
3882 assert!(out.contains("serde = { version = \"1\", features = [\"derive\"] }"));
3883 assert!(out.contains("inner = { path = \"crates/inner\", version = \"0.2.0\" }"));
3884 }
3885
3886 #[test]
3890 fn cargo_version_rewrite_without_workspace_dependencies_table_still_bumps_package() {
3891 let toml = "[workspace.package]\nversion = \"0.9.0\"\nedition = \"2024\"\n";
3892 let out = rewrite_cargo_version(toml, "0.10.0").unwrap();
3893 assert_eq!(
3894 out,
3895 "[workspace.package]\nversion = \"0.10.0\"\nedition = \"2024\"\n"
3896 );
3897 }
3898
3899 #[test]
3902 fn cargo_version_rewrite_handles_a_kanade_shaped_workspace_dependencies_table() {
3903 let toml = "\
3904[workspace.package]\n\
3905version = \"0.48.2\"\n\
3906\n\
3907[workspace.dependencies]\n\
3908anyhow = { version = \"1\" }\n\
3909serde = { version = \"1\", features = [\"derive\"] }\n\
3910kanade-shared = { path = \"crates/kanade-shared\", version = \"0.48.2\" }\n\
3911kanade-core = { path = \"crates/kanade-core\", version = \"0.48.2\" }\n\
3912kanade-internal-tool = { path = \"crates/kanade-internal-tool\" }\n";
3913 let out = rewrite_cargo_version(toml, "0.48.3").unwrap();
3914 assert!(out.contains("anyhow = { version = \"1\" }"));
3915 assert!(out.contains("serde = { version = \"1\", features = [\"derive\"] }"));
3916 assert!(
3917 out.contains(
3918 "kanade-shared = { path = \"crates/kanade-shared\", version = \"0.48.3\" }"
3919 )
3920 );
3921 assert!(
3922 out.contains("kanade-core = { path = \"crates/kanade-core\", version = \"0.48.3\" }")
3923 );
3924 assert!(out.contains("kanade-internal-tool = { path = \"crates/kanade-internal-tool\" }"));
3925 }
3926
3927 #[test]
3931 fn cargo_version_rewrite_bails_on_an_unrepresentable_inline_table() {
3932 let toml = "\
3933[workspace.package]\n\
3934version = \"0.1.0\"\n\
3935\n\
3936[workspace.dependencies]\n\
3937inner = { path = \"crates/inner\",\n\
3938 version = \"0.1.0\" }\n";
3939 assert!(rewrite_cargo_version(toml, "0.2.0").is_err());
3940 }
3941
3942 #[test]
3945 fn cargo_version_rewrite_recognises_a_commented_workspace_dependencies_header() {
3946 let toml = "\
3947[workspace.package]\n\
3948version = \"0.1.0\"\n\
3949\n\
3950[workspace.dependencies] # internal pins\n\
3951inner = { path = \"crates/inner\", version = \"0.1.0\" }\n";
3952 let out = rewrite_cargo_version(toml, "0.2.0").unwrap();
3953 assert!(out.contains("inner = { path = \"crates/inner\", version = \"0.2.0\" }"));
3954 }
3955
3956 #[test]
3959 fn cargo_version_rewrite_bumps_a_quoted_dependency_key() {
3960 let toml = "\
3961[workspace.package]\n\
3962version = \"0.1.0\"\n\
3963\n\
3964[workspace.dependencies]\n\
3965\"inner\" = { path = \"crates/inner\", version = \"0.1.0\" }\n";
3966 let out = rewrite_cargo_version(toml, "0.2.0").unwrap();
3967 assert!(out.contains("\"inner\" = { path = \"crates/inner\", version = \"0.2.0\" }"));
3968 }
3969
3970 #[test]
3974 fn cargo_version_rewrite_bumps_a_literal_string_version_pin() {
3975 let toml = "\
3976[workspace.package]\n\
3977version = \"0.1.0\"\n\
3978\n\
3979[workspace.dependencies]\n\
3980inner = { path = 'crates/inner', version = '0.1.0' }\n";
3981 let out = rewrite_cargo_version(toml, "0.2.0").unwrap();
3982 assert!(out.contains("inner = { path = 'crates/inner', version = '0.2.0' }"));
3983 }
3984
3985 #[test]
3991 fn cargo_version_rewrite_does_not_require_the_whole_file_to_parse() {
3992 let toml = "\
3993[workspace.package]\n\
3994version = \"0.1.0\"\n\
3995\n\
3996[workspace.dependencies]\n\
3997inner = { path = \"crates/inner\", version = \"0.1.0\" }\n\
3998\n\
3999[workspace.package]\n\
4000edition = \"2024\"\n";
4001 let out = rewrite_cargo_version(toml, "0.2.0").unwrap();
4002 assert!(out.contains("inner = { path = \"crates/inner\", version = \"0.2.0\" }"));
4003 assert!(
4004 toml::from_str::<toml::Value>(toml).is_err(),
4005 "the fixture itself must be invalid as a whole file, or this test proves nothing"
4006 );
4007 }
4008
4009 #[test]
4010 fn current_version_prefers_the_package_table_when_both_exist() {
4011 let toml = "[workspace.package]\nversion = \"9.9.9\"\n\n[package]\nversion = \"0.8.0\"\n";
4012 assert_eq!(current_version(toml).unwrap(), "0.8.0");
4013 }
4014
4015 #[test]
4018 fn current_version_falls_back_to_workspace_package_without_a_package_table() {
4019 let toml = "\
4020[workspace]\n\
4021members = [\"crates/a\", \"crates/b\"]\n\
4022\n\
4023[workspace.package]\n\
4024version = \"0.45.18\"\n";
4025 assert_eq!(current_version(toml).unwrap(), "0.45.18");
4026 }
4027
4028 #[test]
4029 fn coalesce_proceeds_with_nothing_pending() {
4030 assert_eq!(coalesce(None, "0.8.0").unwrap(), Coalesce::Proceed);
4031 }
4032
4033 fn test_pending(target_version: &str, level: BumpLevel) -> PendingBump {
4036 PendingBump {
4037 target_version: target_version.to_owned(),
4038 level,
4039 branch: format!("chore/release-v{target_version}"),
4040 pr_url: "https://example.invalid/pull/9".to_owned(),
4041 }
4042 }
4043
4044 #[test]
4045 fn coalesce_skips_while_the_pending_target_is_still_ahead() {
4046 let pending = test_pending("0.9.0", BumpLevel::Minor);
4047 assert_eq!(
4048 coalesce(Some(&pending), "0.8.0").unwrap(),
4049 Coalesce::Skip {
4050 target_version: "0.9.0".to_owned()
4051 }
4052 );
4053 }
4054
4055 #[test]
4056 fn coalesce_treats_a_landed_or_superseded_pending_bump_as_stale() {
4057 let pending = test_pending("0.9.0", BumpLevel::Minor);
4058 assert_eq!(
4060 coalesce(Some(&pending), "0.9.0").unwrap(),
4061 Coalesce::Proceed
4062 );
4063 assert_eq!(
4065 coalesce(Some(&pending), "1.0.0").unwrap(),
4066 Coalesce::Proceed
4067 );
4068 }
4069
4070 #[test]
4071 fn pending_action_escalates_only_for_a_more_severe_decision() {
4072 assert_eq!(
4073 pending_action(BumpLevel::Patch, BumpLevel::Patch),
4074 PendingAction::AlreadyCovered
4075 );
4076 assert_eq!(
4077 pending_action(BumpLevel::Patch, BumpLevel::Minor),
4078 PendingAction::Escalate
4079 );
4080 assert_eq!(
4081 pending_action(BumpLevel::Patch, BumpLevel::Major),
4082 PendingAction::Escalate
4083 );
4084 assert_eq!(
4085 pending_action(BumpLevel::Minor, BumpLevel::Patch),
4086 PendingAction::AlreadyCovered
4087 );
4088 assert_eq!(
4089 pending_action(BumpLevel::Major, BumpLevel::Minor),
4090 PendingAction::AlreadyCovered
4091 );
4092 assert_eq!(
4093 pending_action(BumpLevel::Major, BumpLevel::Major),
4094 PendingAction::AlreadyCovered
4095 );
4096 }
4097
4098 #[test]
4099 fn pr_state_parsing_reads_open_and_not_open() {
4100 assert!(parse_pr_state(r#"{"state":"OPEN"}"#).unwrap());
4101 assert!(!parse_pr_state(r#"{"state":"CLOSED"}"#).unwrap());
4102 assert!(!parse_pr_state(r#"{"state":"MERGED"}"#).unwrap());
4103 }
4104
4105 #[test]
4106 fn a_lock_is_exclusive_until_dropped() {
4107 let dir = tempfile::tempdir().unwrap();
4108 let marker = dir.path().join("bump").join("deadbeefdeadbeef.json");
4109 let first = MarkerLock::acquire(&marker)
4110 .unwrap()
4111 .expect("first attempt takes the lock");
4112 assert!(
4113 MarkerLock::acquire(&marker).unwrap().is_none(),
4114 "a second attempt must be refused while the first holds it"
4115 );
4116 drop(first);
4117 assert!(
4118 MarkerLock::acquire(&marker).unwrap().is_some(),
4119 "dropping the guard releases the lock for the next attempt"
4120 );
4121 }
4122
4123 #[test]
4124 fn a_stale_lock_is_reclaimed() {
4125 let dir = tempfile::tempdir().unwrap();
4126 let marker = dir.path().join("bump").join("deadbeefdeadbeef.json");
4127 let lock_path = marker.with_extension("lock");
4128 std::fs::create_dir_all(lock_path.parent().unwrap()).unwrap();
4129 std::fs::write(&lock_path, b"").unwrap();
4130 let old = std::time::SystemTime::now() - LOCK_STALE_AFTER - Duration::from_secs(1);
4131 std::fs::OpenOptions::new()
4132 .write(true)
4133 .open(&lock_path)
4134 .unwrap()
4135 .set_modified(old)
4136 .unwrap();
4137 assert!(
4138 MarkerLock::acquire(&marker).unwrap().is_some(),
4139 "a lock older than the stale window must be reclaimed rather than block forever"
4140 );
4141 }
4142
4143 #[tokio::test]
4144 async fn a_contended_lock_is_retried_until_the_holder_releases_it() {
4145 let dir = tempfile::tempdir().unwrap();
4146 let marker = dir.path().join("bump").join("deadbeefdeadbeef.json");
4147 let held = MarkerLock::acquire(&marker)
4148 .unwrap()
4149 .expect("seed the contention");
4150 let releaser = tokio::spawn(async move {
4151 tokio::time::sleep(Duration::from_millis(20)).await;
4152 drop(held);
4153 });
4154 let waited =
4155 wait_for_marker_lock_with(&marker, Duration::from_millis(5), Duration::from_secs(5))
4156 .await
4157 .unwrap();
4158 assert!(
4159 waited.is_some(),
4160 "a merge landing behind another's still-running decision must not be dropped - it \
4161 must wait for that decision to finish and then judge against what it left behind"
4162 );
4163 releaser.await.unwrap();
4164 }
4165
4166 #[tokio::test]
4167 async fn a_lock_held_past_the_ceiling_gives_up() {
4168 let dir = tempfile::tempdir().unwrap();
4169 let marker = dir.path().join("bump").join("deadbeefdeadbeef.json");
4170 let _held = MarkerLock::acquire(&marker).unwrap().unwrap();
4171 let waited =
4172 wait_for_marker_lock_with(&marker, Duration::from_millis(2), Duration::from_millis(10))
4173 .await
4174 .unwrap();
4175 assert!(
4176 waited.is_none(),
4177 "a lock genuinely held past the ceiling must eventually give up rather than wait \
4178 forever"
4179 );
4180 }
4181
4182 #[test]
4183 fn level_between_reads_off_the_differing_digit() {
4184 assert_eq!(
4185 level_between(
4186 Version::parse("0.8.0").unwrap(),
4187 Version::parse("1.0.0").unwrap()
4188 ),
4189 Some(BumpLevel::Major)
4190 );
4191 assert_eq!(
4192 level_between(
4193 Version::parse("0.8.0").unwrap(),
4194 Version::parse("0.9.0").unwrap()
4195 ),
4196 Some(BumpLevel::Minor)
4197 );
4198 assert_eq!(
4199 level_between(
4200 Version::parse("0.8.0").unwrap(),
4201 Version::parse("0.8.1").unwrap()
4202 ),
4203 Some(BumpLevel::Patch)
4204 );
4205 assert_eq!(
4206 level_between(
4207 Version::parse("0.8.0").unwrap(),
4208 Version::parse("0.8.0").unwrap()
4209 ),
4210 None
4211 );
4212 }
4213
4214 #[test]
4215 fn open_release_pr_is_found_among_unrelated_pull_requests() {
4216 let json = r#"[
4217 {"url": "https://example.invalid/pull/1", "headRefName": "feat/something"},
4218 {"url": "https://example.invalid/pull/2", "headRefName": "chore/release-v0.9.0"}
4219 ]"#;
4220 let found = parse_open_release_pr(json).unwrap();
4221 assert_eq!(
4222 found,
4223 Some((
4224 "chore/release-v0.9.0".to_owned(),
4225 "https://example.invalid/pull/2".to_owned()
4226 ))
4227 );
4228 }
4229
4230 #[test]
4231 fn no_open_release_pr_reads_as_none_not_an_error() {
4232 let json =
4233 r#"[{"url": "https://example.invalid/pull/1", "headRefName": "feat/something"}]"#;
4234 assert_eq!(parse_open_release_pr(json).unwrap(), None);
4235 assert_eq!(parse_open_release_pr("[]").unwrap(), None);
4236 }
4237
4238 #[test]
4239 fn marker_round_trips_through_disk() {
4240 let dir = tempfile::tempdir().unwrap();
4241 let path = marker_path(dir.path(), Path::new("/repos/magi"));
4242 assert!(read_marker(&path).is_none());
4243
4244 let marker = test_pending("0.9.0", BumpLevel::Patch);
4245 write_marker(&path, &marker).unwrap();
4246 let read_back = read_marker(&path).unwrap();
4247 assert_eq!(read_back.target_version, "0.9.0");
4248 assert_eq!(read_back.level, BumpLevel::Patch);
4249 assert_eq!(read_back.pr_url, marker.pr_url);
4250
4251 clear_marker(&path);
4252 assert!(read_marker(&path).is_none());
4253 }
4254
4255 #[test]
4256 fn different_repos_get_different_marker_files() {
4257 let dir = tempfile::tempdir().unwrap();
4258 let a = marker_path(dir.path(), Path::new("/repos/a"));
4259 let b = marker_path(dir.path(), Path::new("/repos/b"));
4260 assert_ne!(a, b);
4261 }
4262
4263 #[test]
4267 fn a_bump_pull_requests_own_merge_does_not_retrigger() {
4268 let files = vec!["Cargo.toml".to_owned(), "Cargo.lock".to_owned()];
4269 assert!(
4270 is_release_only(&files),
4271 "the bump pull request's own diff must read as release-only"
4272 );
4273 }
4274
4275 #[test]
4276 fn should_release_bump_reads_only_a_merged_status() {
4277 assert!(should_release_bump(RunStatus::Merged));
4278 for other in [RunStatus::Blocked, RunStatus::Ready, RunStatus::Prep] {
4279 assert!(!should_release_bump(other));
4280 }
4281 }
4282
4283 #[test]
4287 fn all_three_merge_paths_report_pr_lifecycle_merged_case_done() {
4288 let pr = land::PrState {
4289 url: "https://github.com/o/r/pull/1".to_owned(),
4290 number: 1,
4291 state: PrLifecycle::Merged,
4292 checks: land::Checks::Green,
4293 failing: Vec::new(),
4294 review_comments: Vec::new(),
4295 blocking: land::Blocking::No,
4296 };
4297 assert_eq!(
4298 land::decide(&pr, 0, 4, Duration::ZERO),
4299 land::Step::Done { merged: true }
4300 );
4301 assert!(should_release_bump(RunStatus::Merged));
4302 }
4303
4304 #[test]
4309 fn all_three_merge_paths_report_pr_lifecycle_merged_case_direct_merge() {
4310 let pr = land::PrState {
4311 url: "https://github.com/o/r/pull/2".to_owned(),
4312 number: 2,
4313 state: PrLifecycle::Open,
4314 checks: land::Checks::Green,
4315 failing: Vec::new(),
4316 review_comments: Vec::new(),
4317 blocking: land::Blocking::No,
4318 };
4319 assert_eq!(land::decide(&pr, 0, 4, Duration::ZERO), land::Step::Merge);
4320 assert!(should_release_bump(RunStatus::Merged));
4323 }
4324
4325 #[test]
4328 fn all_three_merge_paths_report_pr_lifecycle_merged_case_merged_after_all() {
4329 let argv = land::merge_argv(3, "feat: something");
4330 let outcome = land::merged_after_all(
4331 &argv,
4332 "could not determine current branch: not on any branch",
4333 Some(PrLifecycle::Merged),
4334 );
4335 assert!(outcome.is_some(), "the forge's confirmation must win");
4336 assert!(should_release_bump(RunStatus::Merged));
4337
4338 assert!(land::merged_after_all(&argv, "network error", Some(PrLifecycle::Open)).is_none());
4341 assert!(land::merged_after_all(&argv, "network error", None).is_none());
4342 }
4343
4344 #[test]
4346 fn a_close_or_a_give_up_does_not_trigger_a_bump() {
4347 let pr = land::PrState {
4348 url: "https://github.com/o/r/pull/4".to_owned(),
4349 number: 4,
4350 state: PrLifecycle::Closed,
4351 checks: land::Checks::Green,
4352 failing: Vec::new(),
4353 review_comments: Vec::new(),
4354 blocking: land::Blocking::No,
4355 };
4356 assert_eq!(
4357 land::decide(&pr, 0, 4, Duration::ZERO),
4358 land::Step::Done { merged: false }
4359 );
4360 assert!(!should_release_bump(RunStatus::Blocked));
4361 }
4362
4363 fn shun_files() -> Vec<crate::config::VersionFile> {
4364 use crate::config::{VersionFile, VersionKind};
4365 vec![
4366 VersionFile {
4367 path: "src-tauri/Cargo.toml".to_owned(),
4368 kind: VersionKind::Cargo,
4369 },
4370 VersionFile {
4371 path: "package.json".to_owned(),
4372 kind: VersionKind::Json,
4373 },
4374 VersionFile {
4375 path: "src-tauri/tauri.conf.json".to_owned(),
4376 kind: VersionKind::Json,
4377 },
4378 ]
4379 }
4380
4381 const SHUN_TOML: &str = "[package]\nname = \"shun\"\nversion = \"1.0.0\"\n";
4382 const SHUN_LOCK: &str = "[[package]]\nname = \"shun\"\nversion = \"1.0.0\"\n";
4383
4384 async fn shun_origin(package_version: &str) -> (tempfile::TempDir, PathBuf) {
4385 let pkg = format!("{{\n \"version\": \"{package_version}\"\n}}\n");
4386 let origin = origin_with(&[("README.md", "x\n")]).await;
4387 for (name, body) in [
4388 ("src-tauri/Cargo.toml", SHUN_TOML),
4389 ("src-tauri/Cargo.lock", SHUN_LOCK),
4390 ("package.json", pkg.as_str()),
4391 ("src-tauri/tauri.conf.json", "{ \"version\": \"1.0.0\" }\n"),
4392 ] {
4393 let path = origin.1.join(name);
4394 tokio::fs::create_dir_all(path.parent().unwrap())
4395 .await
4396 .unwrap();
4397 tokio::fs::write(path, body).await.unwrap();
4398 }
4399 git::git(&origin.1, &["add", "-A"]).await.unwrap();
4400 git::git(&origin.1, &["commit", "-m", "shun"])
4401 .await
4402 .unwrap();
4403 git::git(&origin.1, &["push", "origin", "main"])
4404 .await
4405 .unwrap();
4406 origin
4407 }
4408
4409 #[tokio::test]
4410 async fn a_shun_layout_bump_changes_only_the_declared_files_and_the_adjacent_lock() {
4411 let (_d, repo) = shun_origin("1.0.0").await;
4412 let mut state = winner_state(&repo, "main");
4413 state.config.release.version_files = shun_files();
4414 write_release_files(&state, &repo, "1.1.0").await.unwrap();
4415 let status = git::git(&repo, &["status", "--porcelain"]).await.unwrap();
4416 let mut paths: Vec<_> = status.lines().map(|l| l[3..].to_owned()).collect();
4417 paths.sort();
4418 assert_eq!(
4419 paths,
4420 [
4421 "package.json",
4422 "src-tauri/Cargo.lock",
4423 "src-tauri/Cargo.toml",
4424 "src-tauri/tauri.conf.json"
4425 ]
4426 );
4427 let lock = std::fs::read_to_string(repo.join("src-tauri/Cargo.lock")).unwrap();
4428 assert!(lock.contains("version = \"1.1.0\""));
4429 }
4430
4431 #[tokio::test]
4432 async fn an_unconfigured_repo_with_auto_tag_but_no_root_manifest_is_skipped_visibly() {
4433 let (_d, repo) = origin_with(&[("README.md", "x\n")]).await;
4434 let wf = repo.join(".github/workflows");
4435 tokio::fs::create_dir_all(&wf).await.unwrap();
4436 tokio::fs::write(wf.join("auto-tag.yml"), "name: t\n")
4437 .await
4438 .unwrap();
4439 git::git(&repo, &["add", "-A"]).await.unwrap();
4440 git::git(&repo, &["commit", "-m", "wf"]).await.unwrap();
4441 git::git(&repo, &["push", "origin", "main"]).await.unwrap();
4442 let home = tempfile::tempdir().unwrap();
4443 let store = Notices::at(home.path().join("notifications"));
4444 let mut state = winner_state(&repo, "main");
4445 after_merge_at(
4446 &mut state,
4447 "https://example.invalid/pull/1",
4448 Some(home.path()),
4449 Some(&store),
4450 )
4451 .await
4452 .unwrap();
4453 let rec = state.release_bump.clone().expect("a skip is recorded");
4454 assert!(rec.skipped.is_some_and(|s| s.contains("Cargo.toml")));
4455 assert!(
4456 rec.action_required
4457 .is_some_and(|a| a.contains("version_files"))
4458 );
4459 assert!(rec.pr_url.is_none() && !rec.automerge_enabled);
4460 assert_eq!(store.list().len(), 1);
4461 assert!(crate::report::run(&state).contains("SKIPPED"));
4462 }
4463
4464 #[tokio::test]
4465 async fn a_non_rust_repo_without_auto_tag_records_a_skip_without_paging() {
4466 let (_d, repo) = origin_with(&[("README.md", "hi\n")]).await;
4467 let home = tempfile::tempdir().unwrap();
4468 let store = Notices::at(home.path().join("notifications"));
4469 let mut state = winner_state(&repo, "main");
4470 after_merge_at(
4471 &mut state,
4472 "https://example.invalid/pull/1",
4473 Some(home.path()),
4474 Some(&store),
4475 )
4476 .await
4477 .unwrap();
4478 let rec = state.release_bump.clone().unwrap();
4479 assert!(rec.skipped.is_some());
4480 assert!(rec.action_required.is_none());
4481 assert!(store.list().is_empty());
4482 }
4483
4484 #[tokio::test]
4485 async fn disagreeing_version_files_stop_the_bump_and_ask_the_owner() {
4486 let (_d, repo) = shun_origin("0.9.0").await;
4487 let home = tempfile::tempdir().unwrap();
4488 let store = Notices::at(home.path().join("notifications"));
4489 let mut state = winner_state(&repo, "main");
4490 state.config.release.version_files = shun_files();
4491 after_merge_at(
4492 &mut state,
4493 "https://example.invalid/pull/1",
4494 Some(home.path()),
4495 Some(&store),
4496 )
4497 .await
4498 .unwrap();
4499 let rec = state.release_bump.clone().unwrap();
4500 assert!(rec.skipped.is_some_and(|s| s.contains("disagree")));
4501 assert!(rec.action_required.is_some());
4502 assert_eq!(store.list().len(), 1);
4503 assert!(rec.pr_url.is_none());
4504 }
4505
4506 #[tokio::test]
4507 async fn a_change_that_already_raised_the_version_is_left_to_the_repos_auto_tag() {
4508 let (_d, repo) = shun_origin("1.0.0").await;
4509 git::git(&repo, &["checkout", "-b", "feat"]).await.unwrap();
4510 let toml = SHUN_TOML.replace("1.0.0", "1.0.1");
4511 tokio::fs::write(repo.join("src-tauri/Cargo.toml"), toml)
4512 .await
4513 .unwrap();
4514 tokio::fs::write(repo.join("app.ts"), "x\n").await.unwrap();
4515 git::git(&repo, &["add", "-A"]).await.unwrap();
4516 git::git(&repo, &["commit", "-m", "fix and bump"])
4517 .await
4518 .unwrap();
4519 let home = tempfile::tempdir().unwrap();
4520 let store = Notices::at(home.path().join("notifications"));
4521 let mut state = winner_state(&repo, "main");
4522 state.candidates[0].branch = "feat".to_owned();
4523 state.config.release.version_files = shun_files();
4524 after_merge_at(
4525 &mut state,
4526 "https://example.invalid/pull/1",
4527 Some(home.path()),
4528 Some(&store),
4529 )
4530 .await
4531 .unwrap();
4532 let rec = state.release_bump.clone().unwrap();
4533 assert!(
4534 rec.skipped
4535 .is_some_and(|s| s.contains("already") || s.contains("raised"))
4536 );
4537 assert!(rec.pr_url.is_none() && rec.action_required.is_none());
4538 assert!(store.list().is_empty());
4539 }
4540
4541 #[tokio::test]
4542 async fn a_stale_local_base_does_not_make_an_inherited_version_look_like_this_changes() {
4543 let (_d, repo) = shun_origin("1.0.0").await;
4544 let old = git::rev_parse(&repo, "HEAD").await.unwrap();
4545 tokio::fs::write(
4546 repo.join("src-tauri/Cargo.toml"),
4547 SHUN_TOML.replace("1.0.0", "1.0.1"),
4548 )
4549 .await
4550 .unwrap();
4551 git::git(&repo, &["commit", "-am", "bump upstream"])
4552 .await
4553 .unwrap();
4554 git::git(&repo, &["push", "origin", "main"]).await.unwrap();
4555 git::git(&repo, &["checkout", "-b", "feat"]).await.unwrap();
4556 tokio::fs::write(repo.join("app.ts"), "x\n").await.unwrap();
4557 git::git(&repo, &["add", "-A"]).await.unwrap();
4558 git::git(&repo, &["commit", "-m", "fix"]).await.unwrap();
4559 git::git(&repo, &["update-ref", "refs/heads/main", &old])
4561 .await
4562 .unwrap();
4563 let home = tempfile::tempdir().unwrap();
4564 let store = Notices::at(home.path().join("notifications"));
4565 let mut state = winner_state(&repo, "main");
4566 state.candidates[0].branch = "feat".to_owned();
4567 state.config.release.version_files = shun_files();
4568 let _ = after_merge_at(
4569 &mut state,
4570 "https://example.invalid/pull/1",
4571 Some(home.path()),
4572 Some(&store),
4573 )
4574 .await;
4575 assert!(
4576 !state
4577 .events
4578 .iter()
4579 .any(|e| e.message.contains("already moved")),
4580 "{:?}",
4581 state.events
4582 );
4583 }
4584
4585 #[tokio::test]
4586 async fn a_dependency_only_change_on_a_stale_local_base_is_not_release_only() {
4587 let (_d, repo) = shun_origin("1.0.0").await;
4588 let old = git::rev_parse(&repo, "HEAD").await.unwrap();
4589 for (p, from) in [
4590 ("src-tauri/Cargo.toml", SHUN_TOML),
4591 ("package.json", "{\n \"version\": \"1.0.0\"\n}\n"),
4592 ("src-tauri/tauri.conf.json", "{ \"version\": \"1.0.0\" }\n"),
4593 ] {
4594 tokio::fs::write(repo.join(p), from.replace("1.0.0", "1.0.1"))
4595 .await
4596 .unwrap();
4597 }
4598 tokio::fs::write(
4599 repo.join("src-tauri/Cargo.lock"),
4600 SHUN_LOCK.replace("1.0.0", "1.0.1"),
4601 )
4602 .await
4603 .unwrap();
4604 git::git(&repo, &["commit", "-am", "bump upstream"])
4605 .await
4606 .unwrap();
4607 git::git(&repo, &["push", "origin", "main"]).await.unwrap();
4608 git::git(&repo, &["checkout", "-b", "feat"]).await.unwrap();
4609 tokio::fs::write(
4610 repo.join("package.json"),
4611 "{\n \"version\": \"1.0.1\",\n \"dependencies\": {}\n}\n",
4612 )
4613 .await
4614 .unwrap();
4615 git::git(&repo, &["commit", "-am", "deps"]).await.unwrap();
4616 git::git(&repo, &["update-ref", "refs/heads/main", &old])
4617 .await
4618 .unwrap();
4619 let home = tempfile::tempdir().unwrap();
4620 let store = Notices::at(home.path().join("notifications"));
4621 let mut state = winner_state(&repo, "main");
4622 state.candidates[0].branch = "feat".to_owned();
4623 state.config.release.version_files = shun_files();
4624 let _ = after_merge_at(
4625 &mut state,
4626 "https://example.invalid/pull/1",
4627 Some(home.path()),
4628 Some(&store),
4629 )
4630 .await;
4631 assert!(
4632 !state
4633 .events
4634 .iter()
4635 .any(|e| e.message.contains("only the release manifest")),
4636 "{:?}",
4637 state.events
4638 );
4639 assert!(
4640 state
4641 .release_bump
4642 .as_ref()
4643 .is_none_or(|b| b.skipped.is_none())
4644 );
4645 }
4646}