1use std::collections::{HashMap, HashSet};
9use std::error;
10use std::fmt;
11use std::fmt::Display;
12use std::fmt::Formatter;
13use std::fmt::Write as _;
14use std::hash::BuildHasher;
15
16pub const PLAN_LABEL: &str = "orch-plan";
17pub const HUMAN_LABEL: &str = "owner:human";
18pub const NO_AGENT_LABEL: &str = "no-agent";
19pub const HOLD_LABEL: &str = "orch-plan-hold";
22pub const CI_BOOTSTRAP_ID: &str = "CI-01";
23pub const CI_BOOTSTRAP_MARKER: &str = "<!-- orch-ci-bootstrap -->";
24
25#[derive(Debug, Clone, PartialEq, Eq)]
26pub struct PlanError {
27 pub message: String,
28}
29
30impl Display for PlanError {
31 fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
32 f.write_str(&self.message)
33 }
34}
35
36impl error::Error for PlanError {}
37
38impl PlanError {
39 fn new(message: impl Into<String>) -> Self {
40 Self {
41 message: message.into(),
42 }
43 }
44}
45
46#[derive(Debug, Clone, PartialEq, Eq)]
47pub struct Milestone {
48 pub id: String,
49 pub title: String,
50 pub heading: String,
52}
53
54#[derive(Debug, Clone, PartialEq, Eq)]
55pub struct Task {
56 pub id: String,
57 pub title: String,
58 pub milestone_id: String,
59 pub milestone_title: String,
60 pub milestone_heading: String,
61 pub anchor_heading: String,
63 pub goal: String,
64 pub scope: String,
65 pub acceptance: Vec<String>,
66 pub depends_on: Vec<String>,
67 pub owner_human: bool,
68}
69
70#[derive(Debug, Clone, PartialEq, Eq)]
71pub struct Roadmap {
72 pub milestones: Vec<Milestone>,
73 pub tasks: Vec<Task>,
74}
75
76#[derive(Debug, Clone, Copy, PartialEq, Eq)]
77pub enum ChangeKind {
78 Create,
79 Update,
80 Unchanged,
81}
82
83#[derive(Debug, Clone, PartialEq, Eq)]
84pub struct ExistingIssue {
85 pub task_id: String,
86 pub number: u64,
87 pub database_id: u64,
88 pub title: String,
89 pub body: String,
90 pub labels: Vec<String>,
91 pub state: String,
92}
93
94#[derive(Debug, Clone, PartialEq, Eq)]
95pub struct TaskPlan {
96 pub task: Task,
97 pub kind: ChangeKind,
98 pub number: Option<u64>,
99 pub database_id: Option<u64>,
100 pub existing_labels: Vec<String>,
101}
102
103#[derive(Debug, Clone, PartialEq, Eq)]
104pub struct RemovedTask {
105 pub task_id: String,
106 pub number: u64,
107 pub state: String,
108}
109
110#[derive(Debug, Clone, PartialEq, Eq)]
111pub struct PlanDiff {
112 pub tasks: Vec<TaskPlan>,
113 pub removed: Vec<RemovedTask>,
114}
115
116#[derive(Debug, Clone, PartialEq, Eq)]
118pub struct UnmetExternal {
119 pub task_id: String,
120 pub blocking_task_id: String,
121}
122
123#[derive(Debug, Clone, PartialEq, Eq)]
124pub struct Binding {
125 pub task_id: String,
126 pub number: Option<u64>,
127 pub database_id: Option<u64>,
128}
129
130#[derive(Debug, Clone, PartialEq, Eq)]
131pub struct DepRef {
132 pub number: u64,
133 pub database_id: u64,
134}
135
136#[derive(Debug, Clone, PartialEq, Eq)]
137pub enum LinkEdit {
138 Add {
139 task_id: String,
140 issue_number: Option<u64>,
141 blocking_task_id: String,
142 blocking_number: Option<u64>,
143 blocking_database_id: Option<u64>,
144 },
145 Remove {
146 task_id: String,
147 issue_number: u64,
148 blocking_number: u64,
149 blocking_database_id: u64,
150 },
151}
152
153struct Draft {
154 id: String,
155 title: String,
156 milestone_id: String,
157 milestone_title: String,
158 milestone_heading: String,
159 anchor_heading: String,
160 goal: String,
161 scope: String,
162 acceptance: Vec<String>,
163 depends_raw: Option<String>,
164 owner_human: bool,
165 in_acceptance: bool,
166 line: usize,
167}
168
169#[derive(Clone, Copy)]
170struct TableCols {
171 task: usize,
172 goal: Option<usize>,
173 scope: Option<usize>,
174 acceptance: Option<usize>,
175 depends: Option<usize>,
176 owner: Option<usize>,
177}
178
179pub fn parse_roadmap(markdown: &str) -> Result<Roadmap, PlanError> {
180 parse_roadmap_for(markdown, None).map(|(roadmap, _)| roadmap)
181}
182
183pub fn parse_roadmap_for(
185 markdown: &str,
186 milestone: Option<&str>,
187) -> Result<(Roadmap, Vec<String>), PlanError> {
188 let mut milestones = Vec::new();
189 let mut tasks = Vec::new();
190 let mut errors = Vec::new();
191 let mut current: Option<Milestone> = None;
192 let mut draft: Option<Draft> = None;
193 let mut table: Option<TableCols> = None;
194 let mut seen = HashSet::new();
195 let mut tags: Vec<Option<String>> = Vec::new();
196 let mut tag: Option<String> = None;
197
198 for (idx, raw) in markdown.lines().enumerate() {
199 tags.resize(errors.len(), tag.clone());
200 tag = current.as_ref().map(|item| item.id.clone());
201 let line = raw.trim_end_matches('\r');
202 let line_no = idx + 1;
203
204 if let Some(cols) = table {
205 if line.trim().starts_with('|') {
206 if !is_separator_row(line)
207 && let Some(milestone) = current.as_ref()
208 {
209 match task_from_row(line, &cols, milestone, line_no) {
210 Ok(Some(task)) => {
211 push_task(task, &mut tasks, &mut seen, &mut errors);
212 }
213 Ok(None) => {}
214 Err(err) => errors.push(err),
215 }
216 }
217 continue;
218 }
219 table = None;
220 }
221
222 if let Some(rest) = line.strip_prefix("### ") {
223 flush_draft(&mut draft, &mut tasks, &mut seen, &mut errors);
224 let Some(milestone) = current.as_ref() else {
225 errors.push(format!(
226 "line {line_no}: task heading is outside a milestone"
227 ));
228 continue;
229 };
230 if let Some((id, title)) = parse_task_heading(rest) {
231 if title.is_empty() {
232 errors.push(format!("line {line_no}: {id} has no title"));
233 } else {
234 draft = Some(Draft::new(id, title, milestone, rest.trim(), line_no));
235 }
236 }
237 continue;
238 }
239
240 if let Some(rest) = line.strip_prefix("## ") {
241 flush_draft(&mut draft, &mut tasks, &mut seen, &mut errors);
242 if let Some((id, title)) = parse_milestone_heading(rest) {
243 let milestone = Milestone {
244 id,
245 title,
246 heading: rest.trim().to_string(),
247 };
248 current = Some(milestone.clone());
249 milestones.push(milestone);
250 } else {
251 current = None;
252 }
253 continue;
254 }
255
256 if let Some((cols, unknown)) = table_cols(line) {
257 flush_draft(&mut draft, &mut tasks, &mut seen, &mut errors);
258 if current.is_some() {
259 if !unknown.is_empty() {
260 errors.push(format!(
261 "line {line_no}: unknown table column {}",
262 unknown.join(", ")
263 ));
264 }
265 table = Some(cols);
266 }
267 continue;
268 }
269
270 if let Some(draft) = draft.as_mut() {
271 if let Some((name, value)) = top_level_field(line) {
272 apply_field(draft, name, value);
273 continue;
274 }
275 if draft.in_acceptance && is_acceptance_line(line) {
276 draft.acceptance.push(unindent(line));
277 }
278 }
279 }
280
281 flush_draft(&mut draft, &mut tasks, &mut seen, &mut errors);
282 tags.resize(errors.len(), tag);
283 check_dependencies(&tasks, &mut errors);
284 for message in &errors[tags.len()..] {
285 let id = message
286 .split_whitespace()
287 .next()
288 .and_then(task_milestone_id);
289 tags.push(id.map(str::to_string));
290 }
291
292 let (mut fatal, mut warnings) = (Vec::new(), Vec::new());
293 for (message, tag) in errors.into_iter().zip(tags) {
294 let elsewhere = match (milestone, tag) {
295 (Some(wanted), Some(id)) => !id.eq_ignore_ascii_case(wanted),
296 _ => false,
297 };
298 if elsewhere {
299 warnings.push(message);
300 } else {
301 fatal.push(message);
302 }
303 }
304 if fatal.is_empty() {
305 Ok((Roadmap { milestones, tasks }, warnings))
306 } else {
307 Err(PlanError::new(fatal.join("\n")))
308 }
309}
310
311pub fn select<'a>(
312 roadmap: &'a Roadmap,
313 milestone: Option<&str>,
314) -> Result<Vec<&'a Task>, PlanError> {
315 let Some(wanted) = milestone else {
316 return Ok(roadmap.tasks.iter().collect());
317 };
318 if !roadmap
319 .milestones
320 .iter()
321 .any(|item| item.id.eq_ignore_ascii_case(wanted))
322 {
323 return Err(PlanError::new(format!("no milestone {wanted}")));
324 }
325 Ok(roadmap
326 .tasks
327 .iter()
328 .filter(|task| {
329 task.milestone_id.eq_ignore_ascii_case(wanted) || is_ci_bootstrap_id(&task.id)
330 })
331 .collect())
332}
333
334pub fn issue_title(task: &Task) -> String {
335 if task.title.is_empty() {
336 task.id.clone()
337 } else {
338 format!("{} {}", task.id, task.title)
339 }
340}
341
342pub fn task_anchor(task: &Task) -> String {
343 if task.anchor_heading.is_empty() {
344 github_anchor(&task.milestone_heading)
345 } else {
346 github_anchor(&task.anchor_heading)
347 }
348}
349
350pub fn issue_body(task: &Task, repo: &str, branch: &str, rel_path: &str) -> String {
351 issue_body_with(task, repo, branch, rel_path, &[])
352}
353
354pub fn issue_body_with(
355 task: &Task,
356 repo: &str,
357 branch: &str,
358 rel_path: &str,
359 blocked_external: &[String],
360) -> String {
361 let mut out = String::new();
362 if is_ci_bootstrap_id(&task.id) {
363 out.push_str(CI_BOOTSTRAP_MARKER);
364 out.push('\n');
365 }
366 if !task.goal.is_empty() {
367 out.push_str("## Goal\n\n");
368 out.push_str(task.goal.trim());
369 out.push_str("\n\n");
370 }
371 if !task.scope.is_empty() {
372 out.push_str("## Scope\n\n");
373 out.push_str(task.scope.trim());
374 out.push_str("\n\n");
375 }
376 if !task.acceptance.is_empty() {
377 out.push_str("## Acceptance\n\n");
378 for item in &task.acceptance {
379 let item = item.trim_end();
380 if item.starts_with('-') || item.starts_with('*') || item.starts_with(' ') {
381 out.push_str(item);
382 } else {
383 out.push_str("- ");
384 out.push_str(item);
385 }
386 out.push('\n');
387 }
388 out.push('\n');
389 }
390 if !blocked_external.is_empty() {
391 out.push_str("blocked-external: ");
392 out.push_str(&blocked_external.join(", "));
393 out.push_str(" (no issue yet)\n\n");
394 }
395 if !is_ci_bootstrap_id(&task.id) {
396 let url = format!(
397 "https://github.com/{repo}/blob/{branch}/{path}#{anchor}",
398 branch = encode_git_path(branch),
399 path = encode_git_path(rel_path),
400 anchor = urlencoding::encode(&task_anchor(task)),
401 );
402 let _ = write!(out, "[{rel_path}]({url})\n\n");
403 }
404 if !blocked_external.is_empty() {
405 out.push_str("<!-- orch-blocked-external: ");
406 out.push_str(&blocked_external.join(", "));
407 out.push_str(" -->\n");
408 }
409 out.push_str(&marker_for(&task.id));
410 out.push('\n');
411 out
412}
413
414pub fn marker_for(id: &str) -> String {
415 format!("<!-- orch-plan: {id} -->")
416}
417
418pub fn marker_id(body: &str) -> Option<String> {
419 let start = body.find("<!-- orch-plan:")?;
420 let rest = &body[start + "<!-- orch-plan:".len()..];
421 let end = rest.find("-->")?;
422 let id = rest[..end].trim();
423 is_task_id(id).then(|| id.to_string())
424}
425
426pub fn is_ci_bootstrap_id(id: &str) -> bool {
427 id.eq_ignore_ascii_case(CI_BOOTSTRAP_ID)
428}
429
430pub fn is_ci_bootstrap_body(body: &str) -> bool {
431 body.contains(CI_BOOTSTRAP_MARKER)
432}
433
434pub fn needs_ci_bootstrap(has_workflow: bool, ci_issue_open: bool) -> bool {
436 !has_workflow || ci_issue_open
437}
438
439pub fn inject_ci_bootstrap(roadmap: &mut Roadmap, include_shipcheck: bool) {
441 if !roadmap
442 .tasks
443 .iter()
444 .any(|task| is_ci_bootstrap_id(&task.id))
445 {
446 if !roadmap
447 .milestones
448 .iter()
449 .any(|milestone| milestone.id.eq_ignore_ascii_case("CI"))
450 {
451 roadmap.milestones.insert(
452 0,
453 Milestone {
454 id: "CI".to_string(),
455 title: "CI bootstrap".to_string(),
456 heading: "CI. CI bootstrap".to_string(),
457 },
458 );
459 }
460 roadmap
461 .tasks
462 .insert(0, ci_bootstrap_task(include_shipcheck));
463 }
464 for task in &mut roadmap.tasks {
465 if is_ci_bootstrap_id(&task.id) {
466 continue;
467 }
468 if !task.depends_on.iter().any(|dep| is_ci_bootstrap_id(dep)) {
469 task.depends_on.insert(0, CI_BOOTSTRAP_ID.to_string());
470 }
471 }
472}
473
474pub(crate) fn ci_bootstrap_task(include_shipcheck: bool) -> Task {
475 let mut scope = String::from(
476 "Add the smallest project layout that can run tests for this repository's language.\n\
477 Add at least one test that fails if that layout is broken.\n\
478 Add a GitHub Actions workflow under `.github/workflows/` that runs those tests on every push to the default branch.\n\
479 Do not add product features.",
480 );
481 let mut acceptance = vec![
482 "A workflow file exists on the default branch after merge.".to_string(),
483 "Pushing to the default branch runs the workflow.".to_string(),
484 "The workflow reports a passing check.".to_string(),
485 "Tests fail when the skeleton is broken.".to_string(),
486 ];
487 if include_shipcheck {
488 scope.push_str("\nAdd or keep `shipcheck.toml` so local checks match the workflow jobs.");
489 acceptance.push("`shipcheck.toml` lists the same checks the workflow runs.".to_string());
490 }
491 Task {
492 id: CI_BOOTSTRAP_ID.to_string(),
493 title: "Set up CI and tests".to_string(),
494 milestone_id: "CI".to_string(),
495 milestone_title: "CI bootstrap".to_string(),
496 milestone_heading: "CI. CI bootstrap".to_string(),
497 anchor_heading: "CI-01 Set up CI and tests".to_string(),
498 goal: "Give this repository a project skeleton, tests, and a GitHub Actions workflow that runs on every push to the default branch, so later tasks can rely on required checks.".to_string(),
499 scope,
500 acceptance,
501 depends_on: Vec::new(),
502 owner_human: false,
503 }
504}
505
506pub fn labels_for(existing: &[String], human: bool) -> Vec<String> {
508 let drop_no_agent = existing.iter().any(|label| label == HUMAN_LABEL);
509 let mut labels = vec![PLAN_LABEL.to_string()];
510 if human {
511 labels.push(HUMAN_LABEL.to_string());
512 labels.push(NO_AGENT_LABEL.to_string());
513 }
514 for label in existing {
515 if label == PLAN_LABEL || label == HUMAN_LABEL {
516 continue;
517 }
518 if label == NO_AGENT_LABEL && (human || drop_no_agent) {
519 continue;
520 }
521 if !labels.iter().any(|have| have == label) {
522 labels.push(label.clone());
523 }
524 }
525 labels
526}
527
528pub fn diff_import(
529 roadmap: &Roadmap,
530 existing: &[ExistingIssue],
531 milestone: Option<&str>,
532 mut body_for: impl FnMut(&Task) -> String,
533) -> Result<PlanDiff, PlanError> {
534 let selected = select(roadmap, milestone)?;
535 let mut by_id: HashMap<&str, &ExistingIssue> = HashMap::new();
536 let mut errors = Vec::new();
537 for issue in existing {
538 if by_id.insert(issue.task_id.as_str(), issue).is_some() {
539 errors.push(format!(
540 "more than one issue is marked as {}",
541 issue.task_id
542 ));
543 }
544 }
545 if !errors.is_empty() {
546 return Err(PlanError::new(errors.join("\n")));
547 }
548
549 let mut tasks = Vec::new();
550 let mut selected_ids = HashSet::new();
551 for task in selected {
552 selected_ids.insert(task.id.as_str());
553 let title = issue_title(task);
554 let body = body_for(task);
555 let kind = if let Some(issue) = by_id.get(task.id.as_str()) {
556 let same = issue.title == title
557 && normalize_body(&issue.body) == normalize_body(&body)
558 && same_labels(&issue.labels, &labels_for(&issue.labels, task.owner_human));
559 if same {
560 ChangeKind::Unchanged
561 } else {
562 ChangeKind::Update
563 }
564 } else {
565 ChangeKind::Create
566 };
567 let issue = by_id.get(task.id.as_str()).copied();
568 tasks.push(TaskPlan {
569 task: task.clone(),
570 kind,
571 number: issue.map(|item| item.number),
572 database_id: issue.map(|item| item.database_id),
573 existing_labels: issue.map(|item| item.labels.clone()).unwrap_or_default(),
574 });
575 }
576
577 let mut removed = Vec::new();
578 for issue in existing {
579 if selected_ids.contains(issue.task_id.as_str()) || is_ci_bootstrap_id(&issue.task_id) {
580 continue;
581 }
582 if let Some(wanted) = milestone {
583 let Some(prefix) = task_milestone_id(&issue.task_id) else {
584 continue;
585 };
586 if !prefix.eq_ignore_ascii_case(wanted) {
587 continue;
588 }
589 }
590 removed.push(RemovedTask {
591 task_id: issue.task_id.clone(),
592 number: issue.number,
593 state: issue.state.clone(),
594 });
595 }
596
597 Ok(PlanDiff { tasks, removed })
598}
599
600pub fn unmet_externals<S: BuildHasher>(
604 tasks: &[Task],
605 roadmap: &Roadmap,
606 known_ids: &HashSet<String, S>,
607) -> Result<Vec<UnmetExternal>, PlanError> {
608 let selected: HashSet<&str> = tasks.iter().map(|task| task.id.as_str()).collect();
609 let roadmap_ids: HashSet<&str> = roadmap.tasks.iter().map(|task| task.id.as_str()).collect();
610 let mut unmet = Vec::new();
611 let mut errors = Vec::new();
612 for task in tasks {
613 for dep in &task.depends_on {
614 if selected.contains(dep.as_str()) || known_ids.contains(dep) {
615 continue;
616 }
617 if roadmap_ids.contains(dep.as_str()) {
618 unmet.push(UnmetExternal {
619 task_id: task.id.clone(),
620 blocking_task_id: dep.clone(),
621 });
622 } else {
623 errors.push(format!("{} depends on unknown task {dep}", task.id));
624 }
625 }
626 }
627 if errors.is_empty() {
628 Ok(unmet)
629 } else {
630 Err(PlanError::new(errors.join("\n")))
631 }
632}
633
634pub fn skip_unmet_ids(tasks: &[Task], unmet: &[UnmetExternal]) -> HashSet<String> {
636 let mut skip: HashSet<String> = unmet.iter().map(|item| item.task_id.clone()).collect();
637 loop {
638 let mut added = false;
639 for task in tasks {
640 if skip.contains(&task.id) {
641 continue;
642 }
643 if task.depends_on.iter().any(|dep| skip.contains(dep)) {
644 skip.insert(task.id.clone());
645 added = true;
646 }
647 }
648 if !added {
649 break;
650 }
651 }
652 skip
653}
654
655pub fn blocked_external_ids<'a>(unmet: &'a [UnmetExternal], task_id: &str) -> Vec<&'a str> {
656 unmet
657 .iter()
658 .filter(|item| item.task_id == task_id)
659 .map(|item| item.blocking_task_id.as_str())
660 .collect()
661}
662
663pub fn diff_links<S: BuildHasher>(
664 tasks: &[Task],
665 bindings: &[Binding],
666 current: &HashMap<u64, Vec<DepRef>, S>,
667) -> Result<Vec<LinkEdit>, PlanError> {
668 let mut edits = Vec::new();
669 let mut errors = Vec::new();
670 let managed: HashSet<u64> = bindings.iter().filter_map(|item| item.number).collect();
671 for task in tasks {
672 let Some(binding) = bindings.iter().find(|item| item.task_id == task.id) else {
673 errors.push(format!("{} has no issue binding", task.id));
674 continue;
675 };
676 let blocked = binding
677 .number
678 .and_then(|number| current.get(&number))
679 .cloned()
680 .unwrap_or_default();
681 let mut desired_numbers = Vec::new();
682 for dep_id in &task.depends_on {
683 let Some(dep) = bindings.iter().find(|item| item.task_id == dep_id.as_str()) else {
684 continue;
685 };
686 if let Some(number) = dep.number {
687 desired_numbers.push(number);
688 }
689 let already = dep
690 .number
691 .is_some_and(|number| blocked.iter().any(|item| item.number == number));
692 if !already {
693 edits.push(LinkEdit::Add {
694 task_id: task.id.clone(),
695 issue_number: binding.number,
696 blocking_task_id: dep_id.clone(),
697 blocking_number: dep.number,
698 blocking_database_id: dep.database_id,
699 });
700 }
701 }
702 if let Some(issue_number) = binding.number {
703 for item in &blocked {
704 if desired_numbers.contains(&item.number) || !managed.contains(&item.number) {
706 continue;
707 }
708 edits.push(LinkEdit::Remove {
709 task_id: task.id.clone(),
710 issue_number,
711 blocking_number: item.number,
712 blocking_database_id: item.database_id,
713 });
714 }
715 }
716 }
717 if errors.is_empty() {
718 Ok(edits)
719 } else {
720 Err(PlanError::new(errors.join("\n")))
721 }
722}
723
724pub fn render(diff: &PlanDiff, links: &[LinkEdit], dry_run: bool) -> String {
725 render_report(diff, links, &[], &[], dry_run)
726}
727
728pub fn render_report(
729 diff: &PlanDiff,
730 links: &[LinkEdit],
731 unmet: &[UnmetExternal],
732 skipped: &[String],
733 dry_run: bool,
734) -> String {
735 let mut out = render_tasks(diff);
736 out.push_str(&render_unmet(unmet, skipped));
737 out.push_str(&render_links(links));
738 out.push_str(&render_summary(diff, links, dry_run));
739 out
740}
741
742fn render_unmet(unmet: &[UnmetExternal], skipped: &[String]) -> String {
743 let skip: HashSet<&str> = skipped.iter().map(String::as_str).collect();
744 let mut out = String::new();
745 for id in skipped {
746 let deps = blocked_external_ids(unmet, id);
747 if deps.is_empty() {
748 let _ = writeln!(out, "skip {id}");
749 } else {
750 let _ = writeln!(
751 out,
752 "skip {id} depends on {}, which has no issue yet",
753 deps.join(", ")
754 );
755 }
756 }
757 let mut seen = HashSet::new();
758 for item in unmet {
759 if skip.contains(item.task_id.as_str()) || !seen.insert(item.task_id.as_str()) {
760 continue;
761 }
762 let deps = blocked_external_ids(unmet, &item.task_id);
763 let _ = writeln!(
764 out,
765 "blocked-external {} depends on {}, which has no issue yet",
766 item.task_id,
767 deps.join(", ")
768 );
769 }
770 out
771}
772
773pub fn render_outline(roadmap: &Roadmap) -> String {
774 let mut out = String::new();
775 for milestone in &roadmap.milestones {
776 let _ = writeln!(out, "{} {}", milestone.id, milestone.title);
777 for task in roadmap
778 .tasks
779 .iter()
780 .filter(|task| task.milestone_id == milestone.id)
781 {
782 let human = if task.owner_human { " [human]" } else { "" };
783 let deps = if task.depends_on.is_empty() {
784 "none".to_string()
785 } else {
786 task.depends_on.join(", ")
787 };
788 let _ = writeln!(out, " {} {}{human}", task.id, task.title);
789 let _ = writeln!(out, " depends on: {deps}");
790 }
791 out.push('\n');
792 }
793 out
794}
795
796pub fn render_tasks(diff: &PlanDiff) -> String {
797 let mut out = String::new();
798 for plan in &diff.tasks {
799 let human = if plan.task.owner_human {
800 " [human]"
801 } else {
802 ""
803 };
804 let deps = if plan.task.depends_on.is_empty() {
805 "none".to_string()
806 } else {
807 plan.task.depends_on.join(", ")
808 };
809 let _ = writeln!(
810 out,
811 "{kind} {title}{human}\n depends on: {deps}",
812 kind = kind_word(plan.kind),
813 title = issue_title(&plan.task),
814 );
815 }
816 for removed in &diff.removed {
817 let _ = writeln!(
818 out,
819 "removed {} issue #{} ({}), not closed",
820 removed.task_id, removed.number, removed.state
821 );
822 }
823 out
824}
825
826pub fn render_links(links: &[LinkEdit]) -> String {
827 let mut out = String::new();
828 for link in links {
829 match link {
830 LinkEdit::Add {
831 task_id,
832 issue_number,
833 blocking_task_id,
834 blocking_number,
835 ..
836 } => {
837 let _ = writeln!(
838 out,
839 "link {task_id}{issue} blocked by {blocking_task_id}{blocking}",
840 issue = number_suffix(*issue_number),
841 blocking = number_suffix(*blocking_number),
842 );
843 }
844 LinkEdit::Remove {
845 task_id,
846 blocking_number,
847 ..
848 } => {
849 let _ = writeln!(out, "unlink {task_id} blocked by #{blocking_number}");
850 }
851 }
852 }
853 out
854}
855
856pub fn render_summary(diff: &PlanDiff, links: &[LinkEdit], dry_run: bool) -> String {
857 let creates = diff
858 .tasks
859 .iter()
860 .filter(|plan| plan.kind == ChangeKind::Create)
861 .count();
862 let updates = diff
863 .tasks
864 .iter()
865 .filter(|plan| plan.kind == ChangeKind::Update)
866 .count();
867 let unchanged = diff
868 .tasks
869 .iter()
870 .filter(|plan| plan.kind == ChangeKind::Unchanged)
871 .count();
872 let prefix = if dry_run { "dry run: " } else { "" };
873 format!(
874 "{prefix}create {creates}, update {updates}, unchanged {unchanged}, link {}, removed {}\n",
875 links.len(),
876 diff.removed.len()
877 )
878}
879
880pub fn github_anchor(heading: &str) -> String {
881 let mut out = String::new();
882 let mut prev_hyphen = false;
883 for ch in heading.chars() {
884 if ch.is_whitespace() {
885 if !out.is_empty() && !prev_hyphen {
886 out.push('-');
887 prev_hyphen = true;
888 }
889 continue;
890 }
891 if ch == '-' || ch == '_' {
892 if !out.is_empty() && !prev_hyphen {
893 out.push(ch);
894 prev_hyphen = true;
895 }
896 continue;
897 }
898 if ch.is_alphanumeric() {
899 for lower in ch.to_lowercase() {
900 out.push(lower);
901 }
902 prev_hyphen = false;
903 }
904 }
905 while out.ends_with('-') || out.ends_with('_') {
906 out.pop();
907 }
908 out
909}
910
911fn encode_git_path(path: &str) -> String {
912 path.split('/')
913 .map(|segment| urlencoding::encode(segment).into_owned())
914 .collect::<Vec<_>>()
915 .join("/")
916}
917
918fn kind_word(kind: ChangeKind) -> &'static str {
919 match kind {
920 ChangeKind::Create => "create",
921 ChangeKind::Update => "update",
922 ChangeKind::Unchanged => "unchanged",
923 }
924}
925
926fn number_suffix(number: Option<u64>) -> String {
927 match number {
928 Some(number) if number > 0 => format!(" (#{number})"),
929 _ => String::new(),
930 }
931}
932
933fn normalize_body(body: &str) -> String {
934 body.replace("\r\n", "\n").trim().to_string()
935}
936
937fn same_labels(left: &[String], right: &[String]) -> bool {
938 let left: HashSet<&str> = left.iter().map(String::as_str).collect();
939 let right: HashSet<&str> = right.iter().map(String::as_str).collect();
940 left == right
941}
942
943fn task_milestone_id(task_id: &str) -> Option<&str> {
944 if !is_task_id(task_id) {
945 return None;
946 }
947 task_id.split_once('-').map(|(prefix, _)| prefix)
948}
949
950fn push_task(
951 task: Task,
952 tasks: &mut Vec<Task>,
953 seen: &mut HashSet<String>,
954 errors: &mut Vec<String>,
955) {
956 if !seen.insert(task.id.clone()) {
957 errors.push(format!("duplicate task id {}", task.id));
958 return;
959 }
960 tasks.push(task);
961}
962
963fn flush_draft(
964 draft: &mut Option<Draft>,
965 tasks: &mut Vec<Task>,
966 seen: &mut HashSet<String>,
967 errors: &mut Vec<String>,
968) {
969 let Some(draft) = draft.take() else {
970 return;
971 };
972 match draft.into_task() {
973 Ok(task) => push_task(task, tasks, seen, errors),
974 Err(err) => errors.push(err),
975 }
976}
977
978fn check_dependencies(tasks: &[Task], errors: &mut Vec<String>) {
979 let ids: HashSet<&str> = tasks.iter().map(|task| task.id.as_str()).collect();
980 for task in tasks {
981 for dep in &task.depends_on {
982 if dep == &task.id {
983 errors.push(format!("{} depends on itself", task.id));
984 } else if !ids.contains(dep.as_str()) {
985 errors.push(format!("{} depends on unknown task {dep}", task.id));
986 }
987 }
988 }
989}
990
991fn apply_field(draft: &mut Draft, name: &str, value: &str) {
992 if name.eq_ignore_ascii_case("goal") {
993 draft.in_acceptance = false;
994 draft.goal = value.to_string();
995 } else if name.eq_ignore_ascii_case("scope") {
996 draft.in_acceptance = false;
997 draft.scope = value.to_string();
998 } else if name.eq_ignore_ascii_case("acceptance") {
999 draft.in_acceptance = true;
1000 if !value.is_empty() {
1001 draft.acceptance.push(acceptance_item(value));
1002 }
1003 } else if name.eq_ignore_ascii_case("depends on") {
1004 draft.in_acceptance = false;
1005 draft.depends_raw = Some(value.to_string());
1006 } else if name.eq_ignore_ascii_case("owner") {
1007 draft.in_acceptance = false;
1008 draft.owner_human = is_human_owner(value);
1009 }
1010}
1011
1012fn acceptance_item(value: &str) -> String {
1013 if value.starts_with('-') || value.starts_with('*') {
1014 value.to_string()
1015 } else {
1016 format!("- {value}")
1017 }
1018}
1019
1020fn is_acceptance_line(line: &str) -> bool {
1021 let trimmed = line.trim();
1022 !trimmed.is_empty()
1023 && (line.starts_with(' ')
1024 || line.starts_with('\t')
1025 || trimmed.starts_with("- ")
1026 || trimmed.starts_with("* "))
1027}
1028
1029fn unindent(line: &str) -> String {
1030 let line = line.trim_end();
1031 line.strip_prefix(" ")
1032 .or_else(|| line.strip_prefix('\t'))
1033 .unwrap_or(line)
1034 .to_string()
1035}
1036
1037fn top_level_field(line: &str) -> Option<(&str, &str)> {
1038 let rest = line.strip_prefix("- ")?;
1039 let (name, value) = rest.split_once(':')?;
1040 let name = name.trim();
1041 is_known_field(name).then_some((name, value.trim()))
1042}
1043
1044fn is_known_field(name: &str) -> bool {
1045 name.eq_ignore_ascii_case("goal")
1046 || name.eq_ignore_ascii_case("scope")
1047 || name.eq_ignore_ascii_case("acceptance")
1048 || name.eq_ignore_ascii_case("depends on")
1049 || name.eq_ignore_ascii_case("owner")
1050}
1051
1052fn is_human_owner(value: &str) -> bool {
1053 let Some(word) = value.split_whitespace().next() else {
1054 return false;
1055 };
1056 word.trim_matches(|ch: char| matches!(ch, '.' | ',' | ';' | ':'))
1057 .eq_ignore_ascii_case("human")
1058}
1059
1060fn parse_depends(raw: &str) -> Result<Vec<String>, String> {
1061 let trimmed = raw.trim().trim_end_matches('.').trim();
1062 if trimmed.is_empty() {
1063 return Ok(Vec::new());
1064 }
1065 let first = trimmed.split_whitespace().next().unwrap_or("");
1066 let first = first.trim_matches(|ch: char| matches!(ch, '.' | ',' | ';' | ':'));
1067 if first.eq_ignore_ascii_case("none") {
1069 return Ok(Vec::new());
1070 }
1071 let ids = extract_ids(trimmed);
1072 if ids.is_empty() {
1073 Err(format!("depends on value \"{trimmed}\" has no task id"))
1074 } else {
1075 Ok(ids)
1076 }
1077}
1078
1079fn extract_ids(raw: &str) -> Vec<String> {
1080 let bytes = raw.as_bytes();
1081 let mut ids = Vec::new();
1082 let mut index = 0;
1083 while index < bytes.len() {
1084 if bytes[index].is_ascii_alphabetic() {
1085 let start = index;
1086 index += 1;
1087 while index < bytes.len()
1088 && (bytes[index].is_ascii_alphanumeric() || bytes[index] == b'-')
1089 {
1090 index += 1;
1091 }
1092 let token = &raw[start..index];
1093 if is_task_id(token) && !ids.iter().any(|id| id == token) {
1094 ids.push(token.to_string());
1095 }
1096 continue;
1097 }
1098 index += 1;
1099 }
1100 ids
1101}
1102
1103fn is_task_id(token: &str) -> bool {
1104 if is_ci_bootstrap_id(token) {
1105 return true;
1106 }
1107 let Some((milestone, rest)) = token.split_once('-') else {
1108 return false;
1109 };
1110 if !is_milestone_id(milestone) || rest.is_empty() || !rest.as_bytes()[0].is_ascii_digit() {
1111 return false;
1112 }
1113 rest.bytes().all(|byte| byte.is_ascii_alphanumeric())
1114}
1115
1116fn is_milestone_id(token: &str) -> bool {
1117 let mut chars = token.chars();
1118 let Some(first) = chars.next() else {
1119 return false;
1120 };
1121 if !first.is_ascii_alphabetic() {
1122 return false;
1123 }
1124 let mut saw_digit = false;
1125 for ch in chars {
1126 if ch.is_ascii_digit() {
1127 saw_digit = true;
1128 } else if !ch.is_ascii_alphabetic() {
1129 return false;
1130 }
1131 }
1132 saw_digit
1133}
1134
1135pub(crate) fn is_milestone_heading(line: &str) -> bool {
1136 line.trim_start()
1137 .strip_prefix("## ")
1138 .and_then(parse_milestone_heading)
1139 .is_some()
1140}
1141
1142fn parse_milestone_heading(rest: &str) -> Option<(String, String)> {
1143 let rest = rest.trim();
1144 let (first, title) = rest.split_once(char::is_whitespace)?;
1145 let id = first.trim_end_matches('.');
1146 is_milestone_id(id).then(|| (id.to_string(), title.trim().to_string()))
1147}
1148
1149fn parse_task_heading(rest: &str) -> Option<(String, String)> {
1150 let rest = rest.trim();
1151 let (id, title) = match rest.split_once(char::is_whitespace) {
1152 Some((id, title)) => (id, title.trim()),
1153 None => (rest, ""),
1154 };
1155 is_task_id(id).then(|| (id.to_string(), title.to_string()))
1156}
1157
1158fn table_cols(line: &str) -> Option<(TableCols, Vec<String>)> {
1159 if !line.trim().starts_with('|') {
1160 return None;
1161 }
1162 let cells = split_cells(line);
1163 let names: Vec<String> = cells.iter().map(|cell| cell.to_ascii_lowercase()).collect();
1164 let task = names.iter().position(|name| name == "task")?;
1165 if !names.iter().any(|name| name == "depends on") {
1166 return None;
1167 }
1168 let unknown = cells
1169 .iter()
1170 .zip(names.iter())
1171 .filter(|(_, name)| !name.is_empty() && !is_known_table_column(name))
1172 .map(|(cell, _)| cell.clone())
1173 .collect();
1174 let pos = |label: &str| names.iter().position(|name| name == label);
1175 Some((
1176 TableCols {
1177 task,
1178 goal: pos("goal"),
1179 scope: pos("scope"),
1180 acceptance: pos("acceptance"),
1181 depends: pos("depends on"),
1182 owner: pos("owner"),
1183 },
1184 unknown,
1185 ))
1186}
1187
1188fn is_known_table_column(name: &str) -> bool {
1189 name.eq_ignore_ascii_case("task") || is_known_field(name)
1190}
1191
1192fn is_separator_row(line: &str) -> bool {
1193 let cells = split_cells(line);
1194 !cells.is_empty()
1195 && cells.iter().all(|cell| {
1196 let token = cell.trim_matches(':');
1197 !token.is_empty() && token.chars().all(|ch| ch == '-')
1198 })
1199}
1200
1201fn split_cells(line: &str) -> Vec<String> {
1202 line.trim()
1203 .trim_matches('|')
1204 .split('|')
1205 .map(|cell| cell.trim().to_string())
1206 .collect()
1207}
1208
1209fn cell(cells: &[String], index: Option<usize>) -> &str {
1210 index
1211 .and_then(|index| cells.get(index))
1212 .map_or("", String::as_str)
1213}
1214
1215fn task_from_row(
1216 line: &str,
1217 cols: &TableCols,
1218 milestone: &Milestone,
1219 line_no: usize,
1220) -> Result<Option<Task>, String> {
1221 let cells = split_cells(line);
1222 let task_cell = cell(&cells, Some(cols.task));
1223 let Some((id, title)) = parse_task_heading(task_cell) else {
1224 return Ok(None);
1225 };
1226 if title.is_empty() {
1227 return Err(format!("line {line_no}: {id} has no title"));
1228 }
1229 let depends_raw = cell(&cells, cols.depends);
1230 let depends_on =
1231 parse_depends(depends_raw).map_err(|err| format!("line {line_no}: {id} {err}"))?;
1232 let owner = cell(&cells, cols.owner);
1233 Ok(Some(Task {
1234 id,
1235 title,
1236 milestone_id: milestone.id.clone(),
1237 milestone_title: milestone.title.clone(),
1238 milestone_heading: milestone.heading.clone(),
1239 anchor_heading: String::new(),
1240 goal: cell(&cells, cols.goal).to_string(),
1241 scope: cell(&cells, cols.scope).to_string(),
1242 acceptance: {
1243 let value = cell(&cells, cols.acceptance);
1244 if value.is_empty() {
1245 Vec::new()
1246 } else {
1247 vec![acceptance_item(value)]
1248 }
1249 },
1250 depends_on,
1251 owner_human: is_human_owner(owner),
1252 }))
1253}
1254
1255impl Draft {
1256 fn new(
1257 id: String,
1258 title: String,
1259 milestone: &Milestone,
1260 anchor_heading: &str,
1261 line: usize,
1262 ) -> Self {
1263 Self {
1264 id,
1265 title,
1266 milestone_id: milestone.id.clone(),
1267 milestone_title: milestone.title.clone(),
1268 milestone_heading: milestone.heading.clone(),
1269 anchor_heading: anchor_heading.to_string(),
1270 goal: String::new(),
1271 scope: String::new(),
1272 acceptance: Vec::new(),
1273 depends_raw: None,
1274 owner_human: false,
1275 in_acceptance: false,
1276 line,
1277 }
1278 }
1279
1280 fn into_task(self) -> Result<Task, String> {
1281 let depends_on = match self.depends_raw {
1282 Some(raw) => parse_depends(&raw)
1283 .map_err(|err| format!("line {}: {} {err}", self.line, self.id))?,
1284 None => Vec::new(),
1285 };
1286 Ok(Task {
1287 id: self.id,
1288 title: self.title,
1289 milestone_id: self.milestone_id,
1290 milestone_title: self.milestone_title,
1291 milestone_heading: self.milestone_heading,
1292 anchor_heading: self.anchor_heading,
1293 goal: self.goal,
1294 scope: self.scope,
1295 acceptance: self.acceptance,
1296 depends_on,
1297 owner_human: self.owner_human,
1298 })
1299 }
1300}
1301
1302#[cfg(test)]
1303mod tests {
1304 use super::*;
1305
1306 const SAMPLE: &str = r"
1307## M1. Content model and pack format
1308
1309### M1-01 Set up the workspace
1310
1311- Goal: a Rust workspace that builds.
1312- Scope: the `api/` workspace.
1313- Acceptance:
1314 - `cargo test` passes on a clean checkout.
1315 - including the ignored tests
1316 - CI fails on a formatting error.
1317- Depends on: none.
1318
1319### M1-02 Content model types
1320
1321- Goal: serde types.
1322- Scope: crates/content.
1323- Acceptance:
1324 - A sample file round-trips.
1325- Depends on: M1-01.
1326
1327### M1-03 Content validation
1328
1329- Owner: human.
1330- Goal: catch broken content.
1331- Scope: content-cli validate.
1332- Acceptance:
1333 - One test per check.
1334- Depends on: M1-02.
1335
1336### M1-04 Festival dates
1337
1338- Goal: resolve dates.
1339- Acceptance:
1340 - Tests for 2026.
1341- Depends on: none. Do it before M1-05.
1342
1343### M1-05 Scheduler
1344
1345- Goal: the guardrail.
1346- Scope: resolve().
1347- Acceptance:
1348 - At least 15 fixtures.
1349
1350## M5. Release
1351
1352### M5-02 Privacy policy
1353
1354- Owner: human (counsel), with an agent draft.
1355- Goal: legal pages.
1356- Acceptance:
1357 - Counsel signs off.
1358- Depends on: M1-05.
1359
1360## M6. Full year and plan editor
1361
1362| Task | Goal | Acceptance | Depends on |
1363|---|---|---|---|
1364| M6-01 Units 4 to 10 | Write the rest of the year | Each pack validates | M1-05, M1-01 |
1365| M6-02 Festival modules | Attach modules | Each shows in Hoje | M6-01 |
1366";
1367
1368 fn roadmap() -> Roadmap {
1369 parse_roadmap(SAMPLE).unwrap()
1370 }
1371
1372 fn task<'a>(roadmap: &'a Roadmap, id: &str) -> &'a Task {
1373 roadmap.tasks.iter().find(|task| task.id == id).unwrap()
1374 }
1375
1376 const SUFFIXED: &str = "## M2S. API security\n\n### M2S-01 Rate limits\n\n- Goal: limit.\n\n## M3. Billing\n\n### M3-01 Invoices\n\n- Goal: bill.\n- Depends on: M9-01\n";
1377
1378 #[test]
1379 fn milestone_ids_may_end_in_letters() {
1380 let (roadmap, _) =
1381 parse_roadmap_for(&SUFFIXED.replace("M9-01", "M2S-01"), Some("M2S")).unwrap();
1382 let selected = select(&roadmap, Some("M2S")).unwrap();
1383 assert_eq!(selected.len(), 1);
1384 assert_eq!(selected[0].id, "M2S-01");
1385 }
1386
1387 #[test]
1388 fn other_milestone_errors_are_warnings_when_one_is_selected() {
1389 let err = parse_roadmap_for(SUFFIXED, Some("M3")).unwrap_err();
1390 assert!(err.message.contains("M3-01 depends on unknown task M9-01"));
1391 let broken = SUFFIXED
1392 .replace("- Goal: limit.\n", "- Depends on: nothing\n")
1393 .replace("- Depends on: M9-01\n", "");
1394 assert!(parse_roadmap(&broken).is_err());
1395 let (roadmap, warnings) = parse_roadmap_for(&broken, Some("M3")).unwrap();
1396 assert_eq!(select(&roadmap, Some("M3")).unwrap().len(), 1);
1397 assert_eq!(warnings.len(), 1);
1398 }
1399
1400 #[test]
1401 fn milestone_heading_needs_an_id_and_a_title() {
1402 assert!(is_milestone_heading("## M1. Workspace"));
1403 assert!(is_milestone_heading(" ## M2S. API"));
1404 assert!(!is_milestone_heading("## Notes"));
1405 assert!(!is_milestone_heading("### M1-01 Task"));
1406 assert!(!is_milestone_heading("## M1"));
1407 }
1408
1409 #[test]
1410 fn outline_lists_milestones_tasks_and_dependencies() {
1411 let outline = render_outline(&roadmap());
1412 assert!(
1413 outline.contains("M1 Content model and pack format"),
1414 "{outline}"
1415 );
1416 assert!(
1417 outline.contains(" M1-01 Set up the workspace\n depends on: none"),
1418 "{outline}"
1419 );
1420 assert!(
1421 outline.contains(" M1-02 Content model types\n depends on: M1-01"),
1422 "{outline}"
1423 );
1424 assert!(
1425 outline.contains(" M5-02 Privacy policy [human]\n depends on: M1-05"),
1426 "{outline}"
1427 );
1428 assert!(
1429 outline.contains("M6 Full year and plan editor"),
1430 "{outline}"
1431 );
1432 assert!(
1433 outline.contains(" M6-01 Units 4 to 10\n depends on: M1-05, M1-01"),
1434 "{outline}"
1435 );
1436 }
1437
1438 #[test]
1439 fn parses_nested_acceptance_and_missing_depends_on() {
1440 let roadmap = roadmap();
1441 let first = task(&roadmap, "M1-01");
1442 assert_eq!(
1443 first.acceptance,
1444 vec![
1445 "- `cargo test` passes on a clean checkout.".to_string(),
1446 " - including the ignored tests".to_string(),
1447 "- CI fails on a formatting error.".to_string(),
1448 ]
1449 );
1450 assert!(first.depends_on.is_empty(), "{:?}", first.depends_on);
1451 assert_eq!(first.goal, "a Rust workspace that builds.");
1452 assert_eq!(first.scope, "the `api/` workspace.");
1453
1454 let scheduler = task(&roadmap, "M1-05");
1455 assert!(
1456 scheduler.depends_on.is_empty(),
1457 "{:?}",
1458 scheduler.depends_on
1459 );
1460 assert_eq!(
1461 scheduler.acceptance,
1462 vec!["- At least 15 fixtures.".to_string()]
1463 );
1464 }
1465
1466 #[test]
1467 fn none_with_trailing_prose_adds_no_dependency() {
1468 let roadmap = roadmap();
1469 assert_eq!(task(&roadmap, "M1-04").depends_on, [] as [String; 0]);
1470 }
1471
1472 #[test]
1473 fn parses_owner_human_and_table_dependencies() {
1474 let roadmap = roadmap();
1475 assert!(task(&roadmap, "M1-03").owner_human);
1476 assert!(task(&roadmap, "M5-02").owner_human);
1477 assert!(!task(&roadmap, "M1-01").owner_human);
1478 assert_eq!(
1479 task(&roadmap, "M1-02").depends_on,
1480 vec!["M1-01".to_string()]
1481 );
1482 assert_eq!(
1483 task(&roadmap, "M6-01").depends_on,
1484 vec!["M1-05".to_string(), "M1-01".to_string()]
1485 );
1486 assert_eq!(
1487 task(&roadmap, "M6-02").depends_on,
1488 vec!["M6-01".to_string()]
1489 );
1490 assert_eq!(task(&roadmap, "M6-01").anchor_heading, "");
1491 assert_eq!(task(&roadmap, "M6-01").milestone_id, "M6");
1492 }
1493
1494 #[test]
1495 fn labels_keep_status_and_drop_no_agent_when_a_task_is_no_longer_human() {
1496 let kept = labels_for(
1497 &[
1498 "orch-plan".to_string(),
1499 "owner:human".to_string(),
1500 "no-agent".to_string(),
1501 "status:new".to_string(),
1502 ],
1503 false,
1504 );
1505 assert_eq!(
1506 kept,
1507 vec!["orch-plan".to_string(), "status:new".to_string()]
1508 );
1509
1510 let human = labels_for(&["status:new".to_string(), "no-agent".to_string()], true);
1511 assert_eq!(
1512 human,
1513 vec![
1514 "orch-plan".to_string(),
1515 "owner:human".to_string(),
1516 "no-agent".to_string(),
1517 "status:new".to_string(),
1518 ]
1519 );
1520 }
1521
1522 #[test]
1523 fn unknown_table_column_is_an_error() {
1524 let markdown = r"
1525## M3. Session
1526
1527| Task | Title | Depends on |
1528|---|---|---|
1529| M3-01 Session backfill | ignored | none |
1530";
1531 let err = parse_roadmap(markdown).unwrap_err();
1532 assert!(err.message.contains("Title"), "{}", err.message);
1533 assert!(err.message.contains("line 4"), "{}", err.message);
1534 assert!(
1535 err.message.contains("unknown table column"),
1536 "{}",
1537 err.message
1538 );
1539 }
1540
1541 #[test]
1542 fn table_row_with_only_an_id_has_no_title() {
1543 let markdown = r"
1544## M3. Session
1545
1546| Task | Depends on |
1547|---|---|
1548| M3-01 | none |
1549";
1550 let err = parse_roadmap(markdown).unwrap_err();
1551 assert!(err.message.contains("M3-01"), "{}", err.message);
1552 assert!(err.message.contains("no title"), "{}", err.message);
1553 assert!(err.message.contains("line 6"), "{}", err.message);
1554 }
1555
1556 #[test]
1557 fn heading_task_with_no_title_is_an_error() {
1558 let markdown = r"
1559## M3. Session
1560
1561### M3-01
1562
1563- Goal: backfill.
1564- Depends on: none.
1565";
1566 let err = parse_roadmap(markdown).unwrap_err();
1567 assert!(err.message.contains("M3-01"), "{}", err.message);
1568 assert!(err.message.contains("no title"), "{}", err.message);
1569 assert!(err.message.contains("line 4"), "{}", err.message);
1570 }
1571
1572 #[test]
1573 fn table_owner_column_keeps_title_in_the_task_cell() {
1574 let markdown = r"
1575## M3. Session
1576
1577| Task | Owner | Depends on |
1578|---|---|---|
1579| M3-01 Session backfill | human | none |
1580| M3-02 Follow up | | M3-01 |
1581";
1582 let roadmap = parse_roadmap(markdown).unwrap();
1583 let first = task(&roadmap, "M3-01");
1584 assert_eq!(first.title, "Session backfill");
1585 assert!(first.owner_human);
1586 assert!(first.depends_on.is_empty(), "{:?}", first.depends_on);
1587 let second = task(&roadmap, "M3-02");
1588 assert_eq!(second.title, "Follow up");
1589 assert!(!second.owner_human);
1590 assert_eq!(second.depends_on, vec!["M3-01".to_string()]);
1591 }
1592
1593 #[test]
1594 fn depends_on_without_a_task_id_is_an_error() {
1595 let markdown = r"
1596## M1. Content model
1597
1598### M1-01 First
1599
1600- Goal: one.
1601- Depends on: later today.
1602";
1603 let err = parse_roadmap(markdown).unwrap_err();
1604 assert!(err.message.contains("no task id"), "{}", err.message);
1605 }
1606
1607 #[test]
1608 fn unknown_dependency_is_an_error() {
1609 let markdown = r"
1610## M1. Content model
1611
1612### M1-01 First
1613
1614- Goal: one.
1615- Acceptance:
1616 - done.
1617- Depends on: M1-99.
1618";
1619 let err = parse_roadmap(markdown).unwrap_err();
1620 assert!(
1621 err.message.contains("unknown task M1-99"),
1622 "{}",
1623 err.message
1624 );
1625 assert!(err.message.contains("M1-01"), "{}", err.message);
1626 }
1627
1628 #[test]
1629 fn issue_body_links_the_heading_and_carries_the_marker() {
1630 let roadmap = roadmap();
1631 let task = task(&roadmap, "M1-01");
1632 let body = issue_body(task, "acme/app", "main", "docs/ROADMAP.md");
1633 assert!(body.contains("## Goal\n\na Rust workspace that builds."));
1634 assert!(body.contains("## Scope\n"));
1635 assert!(body.contains("- `cargo test` passes on a clean checkout."));
1636 assert!(body.contains(" - including the ignored tests"));
1637 assert!(body.contains("<!-- orch-plan: M1-01 -->"));
1638 assert!(body.contains(
1639 "https://github.com/acme/app/blob/main/docs/ROADMAP.md#m1-01-set-up-the-workspace"
1640 ));
1641 assert_eq!(marker_id(&body).as_deref(), Some("M1-01"));
1642 assert_eq!(issue_title(task), "M1-01 Set up the workspace");
1643 }
1644
1645 #[test]
1646 fn table_task_links_to_the_milestone_heading() {
1647 let roadmap = roadmap();
1648 let body = issue_body(
1649 task(&roadmap, "M6-01"),
1650 "acme/app",
1651 "main",
1652 "docs/ROADMAP.md",
1653 );
1654 assert!(body.contains("#m6-full-year-and-plan-editor"));
1655 assert!(!body.contains("## Scope"));
1656 }
1657
1658 #[test]
1659 fn report_lists_dependencies_and_marks_human_tasks() {
1660 let roadmap = roadmap();
1661 let diff = diff_import(&roadmap, &[], None, |task| {
1662 issue_body(task, "acme/app", "main", "docs/ROADMAP.md")
1663 })
1664 .unwrap();
1665 let links = diff_links(&roadmap.tasks, &bindings_for(&diff), &HashMap::new()).unwrap();
1666 let text = render(&diff, &links, true);
1667 assert!(text.contains("create M1-01 Set up the workspace\n depends on: none\n"));
1668 assert!(text.contains("create M1-03 Content validation [human]\n depends on: M1-02\n"));
1669 assert!(text.contains("create M5-02 Privacy policy [human]\n depends on: M1-05\n"));
1670 assert!(text.contains("link M6-01 blocked by M1-05\n"));
1671 assert!(text.contains("link M6-01 blocked by M1-01\n"));
1672 assert!(text.starts_with("dry run:") || text.contains("\ndry run:"));
1673 assert!(text.contains("create 8,"));
1674 }
1675
1676 #[test]
1677 fn second_import_with_no_file_change_edits_nothing() {
1678 let roadmap = roadmap();
1679 let existing = existing_for(&roadmap);
1680 let diff = diff_import(&roadmap, &existing, None, |task| {
1681 issue_body(task, "acme/app", "main", "docs/ROADMAP.md")
1682 })
1683 .unwrap();
1684 assert!(
1685 diff.tasks
1686 .iter()
1687 .all(|plan| plan.kind == ChangeKind::Unchanged)
1688 );
1689 assert!(diff.removed.is_empty(), "{:?}", diff.removed);
1690 let current = current_links(&roadmap);
1691 let links =
1692 diff_links(&roadmap.tasks, &bindings_from_existing(&existing), ¤t).unwrap();
1693 assert!(links.is_empty(), "{links:?}");
1694 let text = render(&diff, &links, false);
1695 assert!(text.contains("unchanged M1-02 Content model types"));
1696 assert_eq!(
1697 text.lines()
1698 .filter(|line| line.starts_with("unchanged "))
1699 .count(),
1700 8
1701 );
1702 assert!(
1703 !text
1704 .lines()
1705 .any(|line| line.starts_with("link ") || line.starts_with("unlink "))
1706 );
1707 assert!(text.contains("create 0, update 0, unchanged 8, link 0, removed 0\n"));
1708 }
1709
1710 #[test]
1711 fn changed_body_is_an_update_and_a_dropped_task_is_reported() {
1712 let roadmap = roadmap();
1713 let mut existing = existing_for(&roadmap);
1714 existing[0].body = "stale\n<!-- orch-plan: M1-01 -->\n".to_string();
1715 existing.push(ExistingIssue {
1716 task_id: "M1-99".to_string(),
1717 number: 99,
1718 database_id: 990,
1719 title: "M1-99 Gone".to_string(),
1720 body: marker_for("M1-99"),
1721 labels: labels_for(&[], false),
1722 state: "open".to_string(),
1723 });
1724 let diff = diff_import(&roadmap, &existing, None, |task| {
1725 issue_body(task, "acme/app", "main", "docs/ROADMAP.md")
1726 })
1727 .unwrap();
1728 assert_eq!(diff.tasks[0].kind, ChangeKind::Update);
1729 assert!(
1730 diff.tasks[1..]
1731 .iter()
1732 .all(|plan| plan.kind == ChangeKind::Unchanged)
1733 );
1734 assert_eq!(diff.removed.len(), 1);
1735 assert_eq!(diff.removed[0].task_id, "M1-99");
1736 assert!(render_tasks(&diff).contains("removed M1-99 issue #99 (open), not closed"));
1737 }
1738
1739 #[test]
1740 fn marker_without_label_is_an_update_that_adds_the_label() {
1741 let roadmap = roadmap();
1742 let mut existing = existing_for(&roadmap);
1743 existing[0].labels = vec!["status:new".to_string()];
1744 let diff = diff_import(&roadmap, &existing, None, |task| {
1745 issue_body(task, "acme/app", "main", "docs/ROADMAP.md")
1746 })
1747 .unwrap();
1748 assert_eq!(diff.tasks[0].kind, ChangeKind::Update);
1749 assert_eq!(diff.tasks[0].number, Some(1));
1750 assert!(
1751 labels_for(&diff.tasks[0].existing_labels, false).contains(&PLAN_LABEL.to_string())
1752 );
1753 }
1754
1755 #[test]
1756 fn milestone_filter_limits_tasks_and_removed() {
1757 let roadmap = roadmap();
1758 let mut existing = existing_for(&roadmap);
1759 existing.push(ExistingIssue {
1760 task_id: "M6-09".to_string(),
1761 number: 70,
1762 database_id: 700,
1763 title: "M6-09 Gone".to_string(),
1764 body: marker_for("M6-09"),
1765 labels: labels_for(&[], false),
1766 state: "closed".to_string(),
1767 });
1768 let diff = diff_import(&roadmap, &existing, Some("M6"), |task| {
1769 issue_body(task, "acme/app", "main", "docs/ROADMAP.md")
1770 })
1771 .unwrap();
1772 let ids: Vec<&str> = diff
1773 .tasks
1774 .iter()
1775 .map(|plan| plan.task.id.as_str())
1776 .collect();
1777 assert_eq!(ids, vec!["M6-01", "M6-02"]);
1778 assert_eq!(diff.removed.len(), 1);
1779 assert_eq!(diff.removed[0].task_id, "M6-09");
1780 let err = select(&roadmap, Some("M9")).unwrap_err();
1781 assert!(err.message.contains("no milestone M9"));
1782 }
1783
1784 #[test]
1785 fn milestone_import_links_an_existing_external_issue() {
1786 let roadmap = roadmap();
1787 let existing: Vec<ExistingIssue> = existing_for(&roadmap)
1788 .into_iter()
1789 .filter(|issue| issue.task_id.starts_with("M1-"))
1790 .collect();
1791 let known: HashSet<String> = existing.iter().map(|issue| issue.task_id.clone()).collect();
1792 let selected: Vec<Task> = select(&roadmap, Some("M6"))
1793 .unwrap()
1794 .into_iter()
1795 .cloned()
1796 .collect();
1797 assert_eq!(
1798 unmet_externals(&selected, &roadmap, &known).unwrap(),
1799 [] as [UnmetExternal; 0]
1800 );
1801
1802 let diff = diff_import(&roadmap, &existing, Some("M6"), |task| {
1803 issue_body(task, "acme/app", "main", "docs/ROADMAP.md")
1804 })
1805 .unwrap();
1806 let links = diff_links(
1807 &selected,
1808 &bindings_with_existing(&diff, &existing),
1809 &HashMap::new(),
1810 )
1811 .unwrap();
1812 assert!(links.iter().any(|edit| matches!(
1813 edit,
1814 LinkEdit::Add { task_id, blocking_task_id, blocking_number: Some(5), .. }
1815 if task_id == "M6-01" && blocking_task_id == "M1-05"
1816 )));
1817 assert!(links.iter().any(|edit| matches!(
1818 edit,
1819 LinkEdit::Add { task_id, blocking_task_id, .. }
1820 if task_id == "M6-01" && blocking_task_id == "M1-01"
1821 )));
1822 assert!(links.iter().any(|edit| matches!(
1823 edit,
1824 LinkEdit::Add { task_id, blocking_task_id, .. }
1825 if task_id == "M6-02" && blocking_task_id == "M6-01"
1826 )));
1827 }
1828
1829 #[test]
1830 fn milestone_import_keeps_going_when_an_external_blocker_has_no_issue() {
1831 let roadmap = roadmap();
1832 let selected: Vec<Task> = select(&roadmap, Some("M6"))
1833 .unwrap()
1834 .into_iter()
1835 .cloned()
1836 .collect();
1837 let unmet = unmet_externals(&selected, &roadmap, &HashSet::new()).unwrap();
1838 assert!(
1839 unmet
1840 .iter()
1841 .any(|item| item.task_id == "M6-01" && item.blocking_task_id == "M1-05"),
1842 "{unmet:?}"
1843 );
1844 assert!(
1845 unmet
1846 .iter()
1847 .any(|item| item.task_id == "M6-01" && item.blocking_task_id == "M1-01"),
1848 "{unmet:?}"
1849 );
1850 let extras: Vec<String> = blocked_external_ids(&unmet, "M6-01")
1851 .into_iter()
1852 .map(str::to_string)
1853 .collect();
1854 let body = issue_body_with(
1855 task(&roadmap, "M6-01"),
1856 "acme/app",
1857 "main",
1858 "docs/ROADMAP.md",
1859 &extras,
1860 );
1861 assert!(body.contains("blocked-external: M1-05, M1-01 (no issue yet)"));
1862 assert!(body.contains("<!-- orch-blocked-external: M1-05, M1-01 -->"));
1863 let diff = diff_import(&roadmap, &[], Some("M6"), |task| {
1864 let extra: Vec<String> = blocked_external_ids(&unmet, &task.id)
1865 .into_iter()
1866 .map(str::to_string)
1867 .collect();
1868 issue_body_with(task, "acme/app", "main", "docs/ROADMAP.md", &extra)
1869 })
1870 .unwrap();
1871 assert_eq!(diff.tasks.len(), 2);
1872 assert!(
1873 diff.tasks
1874 .iter()
1875 .all(|plan| plan.kind == ChangeKind::Create)
1876 );
1877 let links = diff_links(&selected, &bindings_for(&diff), &HashMap::new()).unwrap();
1878 assert!(
1879 !links.iter().any(|edit| matches!(
1880 edit,
1881 LinkEdit::Add { blocking_task_id, .. }
1882 if blocking_task_id == "M1-05" || blocking_task_id == "M1-01"
1883 )),
1884 "an unmet external blocker must not be linked: {links:?}"
1885 );
1886 assert!(links.iter().any(|edit| matches!(
1887 edit,
1888 LinkEdit::Add { task_id, blocking_task_id, .. }
1889 if task_id == "M6-02" && blocking_task_id == "M6-01"
1890 )));
1891 let text = render_report(&diff, &links, &unmet, &[], true);
1892 assert!(
1893 text.contains("blocked-external M6-01 depends on M1-05, M1-01, which has no issue yet")
1894 );
1895 let mut known = HashSet::new();
1896 known.insert("M1-05".to_string());
1897 known.insert("M1-01".to_string());
1898 assert_eq!(
1899 unmet_externals(&selected, &roadmap, &known).unwrap(),
1900 [] as [UnmetExternal; 0]
1901 );
1902 }
1903
1904 #[test]
1905 fn skip_unmet_omits_the_dependent_and_tasks_that_wait_on_it() {
1906 let roadmap = roadmap();
1907 let selected: Vec<Task> = select(&roadmap, Some("M6"))
1908 .unwrap()
1909 .into_iter()
1910 .cloned()
1911 .collect();
1912 let unmet = unmet_externals(&selected, &roadmap, &HashSet::new()).unwrap();
1913 let skip = skip_unmet_ids(&selected, &unmet);
1914 assert!(skip.contains("M6-01"));
1915 assert!(skip.contains("M6-02"));
1916 let text = render_report(
1917 &PlanDiff {
1918 tasks: Vec::new(),
1919 removed: Vec::new(),
1920 },
1921 &[],
1922 &unmet,
1923 &["M6-01".to_string(), "M6-02".to_string()],
1924 true,
1925 );
1926 assert!(text.contains("skip M6-01 depends on M1-05, M1-01, which has no issue yet"));
1927 assert!(text.contains("skip M6-02\n"));
1928 assert!(!text.contains("blocked-external M6-01"));
1929 }
1930
1931 #[test]
1932 fn unmet_externals_rejects_an_unknown_id() {
1933 let roadmap = roadmap();
1934 let mut task = task(&roadmap, "M6-01").clone();
1935 task.depends_on = vec!["M9-99".to_string()];
1936 let err = unmet_externals(&[task], &roadmap, &HashSet::new()).unwrap_err();
1937 assert!(
1938 err.message.contains("unknown task M9-99"),
1939 "{}",
1940 err.message
1941 );
1942 assert!(err.message.contains("M6-01"), "{}", err.message);
1943 }
1944
1945 #[test]
1946 fn link_diff_adds_missing_and_removes_extras_then_is_empty() {
1947 let roadmap = roadmap();
1948 let existing = existing_for(&roadmap);
1949 let bindings = bindings_from_existing(&existing);
1950 let stale = number_of(&existing, "M1-05");
1951 let mut current = HashMap::new();
1952 current.insert(
1953 number_of(&existing, "M1-02"),
1954 vec![
1955 DepRef {
1956 number: stale,
1957 database_id: stale * 10,
1958 },
1959 DepRef {
1960 number: 50,
1961 database_id: 500,
1962 },
1963 ],
1964 );
1965 let edits = diff_links(&roadmap.tasks, &bindings, ¤t).unwrap();
1966 assert!(edits.iter().any(|edit| matches!(
1967 edit,
1968 LinkEdit::Add { task_id, blocking_task_id, .. }
1969 if task_id == "M1-02" && blocking_task_id == "M1-01"
1970 )));
1971 assert!(edits.iter().any(|edit| matches!(
1972 edit,
1973 LinkEdit::Remove { task_id, blocking_number, .. }
1974 if task_id == "M1-02" && *blocking_number == stale
1975 )));
1976 assert!(
1977 !edits.iter().any(|edit| matches!(
1978 edit,
1979 LinkEdit::Remove {
1980 blocking_number: 50,
1981 ..
1982 }
1983 )),
1984 "a blocker outside the plan must stay: {edits:?}"
1985 );
1986
1987 let synced = current_links(&roadmap);
1988 let again = diff_links(&roadmap.tasks, &bindings, &synced).unwrap();
1989 assert!(again.is_empty(), "{again:?}");
1990 }
1991
1992 #[test]
1993 fn empty_repo_import_creates_ci_and_blocks_every_other_task() {
1994 let mut roadmap = roadmap();
1995 inject_ci_bootstrap(&mut roadmap, false);
1996 assert_eq!(roadmap.tasks[0].id, CI_BOOTSTRAP_ID);
1997 assert!(roadmap.tasks[0].depends_on.is_empty());
1998 for task in &roadmap.tasks[1..] {
1999 assert_eq!(task.depends_on[0], CI_BOOTSTRAP_ID, "{}", task.id);
2000 }
2001 let diff = diff_import(&roadmap, &[], None, |task| {
2002 issue_body(task, "acme/app", "main", "docs/ROADMAP.md")
2003 })
2004 .unwrap();
2005 assert_eq!(diff.tasks[0].task.id, CI_BOOTSTRAP_ID);
2006 assert_eq!(diff.tasks[0].kind, ChangeKind::Create);
2007 let selected: Vec<Task> = diff.tasks.iter().map(|plan| plan.task.clone()).collect();
2008 let links = diff_links(&selected, &bindings_for(&diff), &HashMap::new()).unwrap();
2009 for plan in &diff.tasks[1..] {
2010 assert!(
2011 links.iter().any(|edit| matches!(
2012 edit,
2013 LinkEdit::Add { task_id, blocking_task_id, .. }
2014 if task_id == &plan.task.id && blocking_task_id == CI_BOOTSTRAP_ID
2015 )),
2016 "{} should be blocked by {CI_BOOTSTRAP_ID}: {links:?}",
2017 plan.task.id
2018 );
2019 }
2020 let body = issue_body(&diff.tasks[0].task, "acme/app", "main", "docs/ROADMAP.md");
2021 assert!(is_ci_bootstrap_body(&body));
2022 assert_eq!(marker_id(&body).as_deref(), Some(CI_BOOTSTRAP_ID));
2023 assert!(body.contains("GitHub Actions workflow"));
2024 assert!(!body.contains("shipcheck.toml"));
2025 assert!(!body.contains("https://github.com/acme/app/blob"));
2026 }
2027
2028 #[test]
2029 fn ci_bootstrap_includes_shipcheck_when_requested() {
2030 let task = ci_bootstrap_task(true);
2031 let body = issue_body(&task, "acme/app", "main", "docs/ROADMAP.md");
2032 assert!(body.contains("shipcheck.toml"));
2033 }
2034
2035 #[test]
2036 fn inject_ci_bootstrap_is_idempotent_and_survives_a_milestone_filter() {
2037 let mut roadmap = roadmap();
2038 inject_ci_bootstrap(&mut roadmap, false);
2039 inject_ci_bootstrap(&mut roadmap, false);
2040 assert_eq!(
2041 roadmap
2042 .tasks
2043 .iter()
2044 .filter(|task| is_ci_bootstrap_id(&task.id))
2045 .count(),
2046 1
2047 );
2048 let selected = select(&roadmap, Some("M1")).unwrap();
2049 assert_eq!(selected[0].id, CI_BOOTSTRAP_ID);
2050 assert!(selected.iter().any(|task| task.id == "M1-01"));
2051 let existing = vec![ExistingIssue {
2052 task_id: CI_BOOTSTRAP_ID.to_string(),
2053 number: 9,
2054 database_id: 90,
2055 title: issue_title(&roadmap.tasks[0]),
2056 body: issue_body(&roadmap.tasks[0], "acme/app", "main", "docs/ROADMAP.md"),
2057 labels: labels_for(&[], false),
2058 state: "open".to_string(),
2059 }];
2060 let diff = diff_import(&roadmap, &existing, Some("M1"), |task| {
2061 issue_body(task, "acme/app", "main", "docs/ROADMAP.md")
2062 })
2063 .unwrap();
2064 assert!(
2065 diff.removed.is_empty(),
2066 "CI-01 must stay when importing another milestone: {:?}",
2067 diff.removed
2068 );
2069 assert_eq!(diff.tasks[0].task.id, CI_BOOTSTRAP_ID);
2070 assert_eq!(diff.tasks[0].kind, ChangeKind::Unchanged);
2071 }
2072
2073 #[test]
2074 fn ci_01_is_a_task_id() {
2075 assert!(is_task_id(CI_BOOTSTRAP_ID));
2076 assert!(is_ci_bootstrap_id("ci-01"));
2077 assert!(!is_task_id("CI"));
2078 assert!(needs_ci_bootstrap(false, false));
2079 assert!(needs_ci_bootstrap(false, true));
2080 assert!(needs_ci_bootstrap(true, true));
2081 assert!(!needs_ci_bootstrap(true, false));
2082 }
2083
2084 #[test]
2085 fn anchor_keeps_letters_and_drops_punctuation() {
2086 assert_eq!(
2087 github_anchor("M1. Content model and pack format"),
2088 "m1-content-model-and-pack-format"
2089 );
2090 assert_eq!(
2091 github_anchor("M3-09 Class screen and Modo áudio"),
2092 "m3-09-class-screen-and-modo-áudio"
2093 );
2094 }
2095
2096 fn existing_for(roadmap: &Roadmap) -> Vec<ExistingIssue> {
2097 roadmap
2098 .tasks
2099 .iter()
2100 .enumerate()
2101 .map(|(index, task)| {
2102 let number = (index + 1) as u64;
2103 ExistingIssue {
2104 task_id: task.id.clone(),
2105 number,
2106 database_id: number * 10,
2107 title: issue_title(task),
2108 body: issue_body(task, "acme/app", "main", "docs/ROADMAP.md"),
2109 labels: labels_for(&["status:new".to_string()], task.owner_human),
2110 state: "open".to_string(),
2111 }
2112 })
2113 .collect()
2114 }
2115
2116 fn bindings_for(diff: &PlanDiff) -> Vec<Binding> {
2117 diff.tasks
2118 .iter()
2119 .map(|plan| Binding {
2120 task_id: plan.task.id.clone(),
2121 number: plan.number,
2122 database_id: plan.database_id,
2123 })
2124 .collect()
2125 }
2126
2127 fn bindings_with_existing(diff: &PlanDiff, existing: &[ExistingIssue]) -> Vec<Binding> {
2128 let mut bindings = bindings_for(diff);
2129 for issue in existing {
2130 if bindings
2131 .iter()
2132 .any(|binding| binding.task_id == issue.task_id)
2133 {
2134 continue;
2135 }
2136 bindings.push(Binding {
2137 task_id: issue.task_id.clone(),
2138 number: Some(issue.number),
2139 database_id: Some(issue.database_id),
2140 });
2141 }
2142 bindings
2143 }
2144
2145 fn bindings_from_existing(existing: &[ExistingIssue]) -> Vec<Binding> {
2146 existing
2147 .iter()
2148 .map(|issue| Binding {
2149 task_id: issue.task_id.clone(),
2150 number: Some(issue.number),
2151 database_id: Some(issue.database_id),
2152 })
2153 .collect()
2154 }
2155
2156 fn number_of(existing: &[ExistingIssue], id: &str) -> u64 {
2157 existing
2158 .iter()
2159 .find(|issue| issue.task_id == id)
2160 .unwrap()
2161 .number
2162 }
2163
2164 fn current_links(roadmap: &Roadmap) -> HashMap<u64, Vec<DepRef>> {
2165 let existing = existing_for(roadmap);
2166 let mut current = HashMap::new();
2167 for task in &roadmap.tasks {
2168 let blocked = task
2169 .depends_on
2170 .iter()
2171 .map(|dep| DepRef {
2172 number: number_of(&existing, dep),
2173 database_id: number_of(&existing, dep) * 10,
2174 })
2175 .collect();
2176 current.insert(number_of(&existing, &task.id), blocked);
2177 }
2178 current
2179 }
2180}