Skip to main content

orch/
plan.rs

1//! Roadmap files and the issue plan `orch plan import` applies.
2//!
3//! A milestone is `## M1. Title`. A task is `### M1-03 Title` with Goal, Scope,
4//! Acceptance, Depends on and Owner lines. Later milestones may be a table with
5//! those columns. An unknown table column or a task with no title is an error.
6//! `none` is no dependency.
7
8use 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    /// Text after `## `, used for the GitHub heading anchor
48    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    /// Full `###` heading. Empty for a table row, which links to the milestone heading
59    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/// A selected task depends on a roadmap id outside the import that has no issue yet
114#[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
180/// With a milestone, errors that belong to other milestones come back as warnings
181pub 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
431/// True when import should add CI-01, because the default branch has no workflow or CI-01 is still open
432pub fn needs_ci_bootstrap(has_workflow: bool, ci_issue_open: bool) -> bool {
433    !has_workflow || ci_issue_open
434}
435
436/// Prepend the CI bootstrap task and make every other task wait on it
437pub 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
503/// Labels for a plan issue. Human tasks also get `no-agent`, which the dispatcher already skips
504pub 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
597/// Dependencies outside the selected set that have no GitHub issue yet.
598///
599/// An id that is not in the roadmap is an error. An id in the roadmap is reported
600pub 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
631/// Task ids to omit when `--skip-unmet` is set, including tasks that depend on a skipped task
632pub 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                // Only drop links to other plan issues, a link a person added by hand stays
702                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    // A leading none is no dependency, even when the rest of the line names a task
1065    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), &current).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, &current).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}