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