From a7140f671b403937a6d51939b608f3518968d928 Mon Sep 17 00:00:00 2001
From: Charlie Ozinga <ozchaz@gmail.com>
Date: Thu, 17 Sep 2020 02:14:30 -0600
Subject: [PATCH] fix: add info cmd and premerge compat

Add the 'info' subcommand, better PR handling for premerge checks, and
make some minor github workflow changes.
---
 .github/snippets/matrix.yml   |  2 -
 .github/workflows/pr.yml      |  2 -
 .github/workflows/release.yml |  2 -
 docs/contributing.md          | 24 ++++++++++
 src/cli.rs                    | 56 +++++++++++++++++++++++
 src/commands.rs               | 39 +++++++++++++++-
 src/config.rs                 |  2 -
 src/git.rs                    | 85 ++++++++++++++++++++++++-----------
 src/github.rs                 | 29 ++++++++----
 src/mono.rs                   | 26 +++++++----
 src/output.rs                 | 57 ++++++++++++++++++-----
 11 files changed, 262 insertions(+), 62 deletions(-)

diff --git a/.github/snippets/matrix.yml b/.github/snippets/matrix.yml
index e882805..093f1c8 100644
--- a/.github/snippets/matrix.yml
+++ b/.github/snippets/matrix.yml
@@ -5,8 +5,6 @@ value:
   - name: Find cargo matrix
     id: find-cargo-matrix
     run: 'echo "::set-output name=matrix::{\"include\": $(versio -l none info -i 0 -R -N)}"'
-  - name: debug
-    run: 'echo "::debug::{\"include\": $(versio -l none info -i 0 -R -N)}"'
   - name: Find all matrix
     id: find-all-matrix
     run: 'echo "::set-output name=matrix::{\"include\": $(versio -l none info -a -R -N)}"'
diff --git a/.github/workflows/pr.yml b/.github/workflows/pr.yml
index b1ba723..f45d9aa 100644
--- a/.github/workflows/pr.yml
+++ b/.github/workflows/pr.yml
@@ -21,8 +21,6 @@ jobs:
       - name: Find cargo matrix
         id: find-cargo-matrix
         run: "echo \"::set-output name=matrix::{\\\"include\\\": $(versio -l none info -i 0 -R -N)}\""
-      - name: debug
-        run: "echo \"::debug::{\\\"include\\\": $(versio -l none info -i 0 -R -N)}\""
       - name: Find all matrix
         id: find-all-matrix
         run: "echo \"::set-output name=matrix::{\\\"include\\\": $(versio -l none info -a -R -N)}\""
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 5717a86..ad3c315 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -21,8 +21,6 @@ jobs:
       - name: Find cargo matrix
         id: find-cargo-matrix
         run: "echo \"::set-output name=matrix::{\\\"include\\\": $(versio -l none info -i 0 -R -N)}\""
-      - name: debug
-        run: "echo \"::debug::{\\\"include\\\": $(versio -l none info -i 0 -R -N)}\""
       - name: Find all matrix
         id: find-all-matrix
         run: "echo \"::set-output name=matrix::{\\\"include\\\": $(versio -l none info -a -R -N)}\""
diff --git a/docs/contributing.md b/docs/contributing.md
index 22b7910..ea6fae2 100644
--- a/docs/contributing.md
+++ b/docs/contributing.md
@@ -25,6 +25,8 @@ versio
 │  └─ ...          . . . . . . . .  src and unit tests
 ├─ tests
 │  └─ ...          . . . . . . . .  integration tests
+└─ .github
+   └─ ...          . . . . . . . .  GitHub Actions
 ```
 
 <!-- 
@@ -148,6 +150,28 @@ shouldn't be unit tested, if the reason isn't obvious.
 To run service tests, run the `builds/test/service-tests.sh` script,
 which runs versio and tests in a docker container.
 
+## GitHub Actions
+
+Versio uses
+[Yambler](https://github.com/chaaz/versio-actions/tree/main/yambler) in
+order to more easily handle repetitive GitHub Actions. The main
+workflows are saved in `.github/workflows-src/` and snippets in
+`.github/snippets/`. When you create or change workflows, just run the
+script `yamble-repo.sh` (available from
+[here](https://github.com/chaaz/versio-actions/blob/main/scripts/yamble-repo.sh))
+which generates workflow files into `~/.github/workflows`.
+
+**DON'T EDIT THE WORKFLOW FILES DIRECTLY**. You should only edit the
+workflow sources in `workflow-src`, or the snippets in `snippets`, and
+then run the `yamble-repo` script. You will still need to
+add/commit/push the generated files in `workflow`, however, in order for
+GitHub Actions to use them.
+
+As mentioned in the Yambler README, you can copy the companion script
+`yamble-repo-pre-push.sh` to a file named `.git/hooks/pre-push` in your
+local copy of the `versio` repo. This will ensure that your workflows
+are synced before you push them up.
+
 ## Platform-specific help
 
 [platform-specific help]: #platform-specific-help
diff --git a/src/cli.rs b/src/cli.rs
index e1c91b9..27352cb 100644
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -222,6 +222,56 @@ pub fn execute(info: &EarlyInfo) -> Result<()> {
         )
         .display_order(1)
     )
+    .subcommand(
+      SubCommand::with_name("info")
+        .setting(AppSettings::UnifiedHelpMessage)
+        .about("Print info about projects")
+        .arg(
+          Arg::with_name("id")
+            .short("i")
+            .long("id")
+            .takes_value(true)
+            .value_name("id")
+            .multiple(true)
+            .number_of_values(1)
+            .min_values(1)
+            .display_order(1)
+            .help("Info on project ID")
+        )
+        .arg(
+          Arg::with_name("name")
+            .short("n")
+            .long("name")
+            .takes_value(true)
+            .value_name("name")
+            .multiple(true)
+            .number_of_values(1)
+            .min_values(1)
+            .display_order(1)
+            .help("Info on project name")
+        )
+        .arg(
+          Arg::with_name("all").short("a").long("all").takes_value(false).display_order(1).help("Info on all projects")
+        )
+        .group(ArgGroup::with_name("which").args(&["id", "name", "all"]).required(false))
+        .arg(
+          Arg::with_name("showroot")
+            .short("R")
+            .long("show-root")
+            .takes_value(false)
+            .display_order(1)
+            .help("Show the project(s) root")
+        )
+        .arg(
+          Arg::with_name("showname")
+            .short("N")
+            .long("show-name")
+            .takes_value(false)
+            .display_order(1)
+            .help("Show the project(s) name")
+        )
+        .display_order(1)
+    )
     .get_matches();
 
   parse_matches(m)
@@ -248,6 +298,12 @@ fn parse_matches(m: ArgMatches) -> Result<()> {
     ("plan", Some(_)) => plan(pref_vcs)?,
     ("release", Some(m)) => release(pref_vcs, m.is_present("all"), m.is_present("dry"))?,
     ("init", Some(m)) => init(m.value_of("maxdepth").map(|d| d.parse().unwrap()).unwrap_or(5))?,
+    ("info", Some(m)) => {
+      let names = m.values_of("name").map(|v| v.collect::<Vec<_>>());
+      let ids =
+        m.values_of("id").map(|v| v.map(|i| i.parse()).collect::<std::result::Result<Vec<_>, _>>()).transpose()?;
+      info(pref_vcs, ids, names, m.is_present("all"), m.is_present("showname"), m.is_present("showroot"))?
+    }
     ("", _) => empty_cmd()?,
     (c, _) => unknown_cmd(c)?
   }
diff --git a/src/commands.rs b/src/commands.rs
index 0a03291..a1e024e 100644
--- a/src/commands.rs
+++ b/src/commands.rs
@@ -1,6 +1,6 @@
 //! The command-line options for the executable.
 
-use crate::config::{Config, ConfigFile, Size};
+use crate::config::{Config, ConfigFile, ProjectId, Size};
 use crate::errors::{Result, ResultExt};
 use crate::git::Repo;
 use crate::mono::Mono;
@@ -150,6 +150,43 @@ pub fn plan(pref_vcs: Option<VcsRange>) -> Result<()> {
   output.commit(&mono)
 }
 
+pub fn info(
+  pref_vcs: Option<VcsRange>, ids: Option<Vec<ProjectId>>, names: Option<Vec<&str>>, all: bool, show_name: bool,
+  show_root: bool
+) -> Result<()> {
+  let mono = build(pref_vcs, VcsLevel::None, VcsLevel::Smart, VcsLevel::None, VcsLevel::Smart)?;
+  let output = Output::new();
+  let mut output = output.info(show_name, show_root);
+
+  let cfg = mono.config();
+  let reader = cfg.state_read();
+
+  if all {
+    output.write_projects(cfg.projects().iter().map(|p| ProjLine::from(p, reader)))?;
+  } else if let Some(ids) = ids {
+    output.write_projects(
+      ids
+        .iter()
+        .map(|id| cfg.get_project(id).ok_or_else(|| bad!("No such project: {}.", id)))
+        .collect::<Result<Vec<_>>>()?
+        .into_iter()
+        .map(|p| ProjLine::from(p, reader))
+    )?;
+  } else if let Some(names) = names {
+    output.write_projects(
+      names
+        .iter()
+        .map(|n| cfg.find_unique(n).map(|id| cfg.get_project(id).unwrap()))
+        .collect::<Result<Vec<_>>>()?
+        .into_iter()
+        .map(|p| ProjLine::from(p, reader))
+    )?;
+  }
+
+  output.commit()?;
+  Ok(())
+}
+
 pub fn release(pref_vcs: Option<VcsRange>, all: bool, dry: bool) -> Result<()> {
   let mut mono = build(pref_vcs, VcsLevel::None, VcsLevel::Smart, VcsLevel::Local, VcsLevel::Smart)?;
   let output = Output::new();
diff --git a/src/config.rs b/src/config.rs
index 2b526d9..683c2e6 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -329,9 +329,7 @@ pub struct Project {
 impl Project {
   pub fn id(&self) -> &ProjectId { &self.id }
   pub fn name(&self) -> &str { &self.name }
-
   pub fn depends(&self) -> &[ProjectId] { &self.depends }
-
   pub fn root(&self) -> Option<&String> { self.root.as_ref().and_then(|r| if r == "." { None } else { Some(r) }) }
 
   fn annotate<S: StateRead>(&self, state: &S) -> Result<AnnotatedMark> {
diff --git a/src/git.rs b/src/git.rs
index c42b937..834406d 100644
--- a/src/git.rs
+++ b/src/git.rs
@@ -201,7 +201,13 @@ impl Repo {
     Ok(E2::B(self.commits_between(from, head_oid, incl_from)?))
   }
 
-  pub fn get_oid_head(&self) -> Result<AnnotatedCommit> { self.get_oid(self.branch_name()?) }
+  pub fn get_oid_head(&self) -> Result<AnnotatedCommit> {
+    if let Some(branch_name) = self.branch_name()? {
+      self.get_oid(branch_name)
+    } else {
+      self.get_oid("HEAD")
+    }
+  }
 
   pub fn get_oid(&self, spec: &str) -> Result<AnnotatedCommit> {
     match &self.vcs {
@@ -212,8 +218,13 @@ impl Repo {
       }
       GitVcsLevel::Remote { repo, branch_name, remote_name, fetches }
       | GitVcsLevel::Smart { repo, branch_name, remote_name, fetches } => {
-        // get_oid_remote() will verify current
-        get_oid_remote(repo, branch_name, spec, remote_name, fetches)
+        if spec == "HEAD" {
+          verify_current(repo).chain_err(|| "Can't complete get.")?;
+          get_oid_local(repo, spec)
+        } else {
+          // get_oid_remote() will verify current
+          get_oid_remote(repo, branch_name, spec, remote_name, fetches)
+        }
       }
     }
   }
@@ -327,6 +338,7 @@ impl Repo {
       | GitVcsLevel::Smart { repo, branch_name, remote_name, .. } => (repo, branch_name, remote_name)
     };
 
+    let branch_name = branch_name.as_ref().ok_or_else(|| bad!("No branch name for push."))?;
     let mut refs = vec![format!("+refs/heads/{}", branch_name)];
     for tag in tags {
       refs.push(format!("+refs/tags/{}", tag));
@@ -346,7 +358,7 @@ impl Repo {
     do_push(repo, remote_name, &[format!("+refs/tags/{}", tag)])
   }
 
-  pub fn branch_name(&self) -> Result<&String> {
+  pub fn branch_name(&self) -> Result<&Option<String>> {
     match &self.vcs {
       GitVcsLevel::None { .. } => err!("No branch name at `none` level."),
       GitVcsLevel::Local { branch_name, .. }
@@ -557,12 +569,14 @@ pub struct FullPr {
   base_time: Time,
   commits: Vec<CommitInfoBuf>,
   excludes: Vec<String>,
-  closed_at: DateTime<FixedOffset>
+  closed_at: DateTime<FixedOffset>,
+  discovery_order: usize
 }
 
 impl FullPr {
   pub fn lookup(
-    repo: &Repo, base: FromTagBuf, headref: String, number: u32, title: String, closed_at: DateTime<FixedOffset>
+    repo: &Repo, base: FromTagBuf, headref: String, number: u32, title: String, closed_at: DateTime<FixedOffset>,
+    discovery_order: usize
   ) -> Result<FullPr> {
     let commit = repo.get_oid(&headref);
     match lookup_from_commit(repo, base.clone(), commit)? {
@@ -577,7 +591,8 @@ impl FullPr {
           base_time: Time::new(0, 0),
           commits: Vec::new(),
           excludes: Vec::new(),
-          closed_at
+          closed_at,
+          discovery_order
         })
       }
       Ok((commit, commits, base_time)) => Ok(FullPr {
@@ -589,7 +604,8 @@ impl FullPr {
         base_time,
         commits,
         excludes: Vec::new(),
-        closed_at
+        closed_at,
+        discovery_order
       })
     }
   }
@@ -604,6 +620,7 @@ impl FullPr {
   pub fn best_guess(&self) -> bool { self.head_oid.is_none() }
   pub fn has_exclude(&self, oid: &str) -> bool { self.excludes.iter().any(|c| c == oid) }
   pub fn closed_at(&self) -> &DateTime<FixedOffset> { &self.closed_at }
+  pub fn discovery_order(&self) -> usize { self.discovery_order }
 
   pub fn included_commits(&self) -> impl Iterator<Item = &CommitInfoBuf> + '_ {
     self.commits.iter().filter(move |c| !self.has_exclude(c.id()))
@@ -660,14 +677,14 @@ impl IterString {
 
 enum GitVcsLevel {
   None { root: PathBuf },
-  Local { repo: Repository, branch_name: String },
-  Remote { repo: Repository, branch_name: String, remote_name: String, fetches: RefCell<HashMap<String, Oid>> },
-  Smart { repo: Repository, branch_name: String, remote_name: String, fetches: RefCell<HashMap<String, Oid>> }
+  Local { repo: Repository, branch_name: Option<String> },
+  Remote { repo: Repository, branch_name: Option<String>, remote_name: String, fetches: RefCell<HashMap<String, Oid>> },
+  Smart { repo: Repository, branch_name: Option<String>, remote_name: String, fetches: RefCell<HashMap<String, Oid>> }
 }
 
 impl GitVcsLevel {
   fn from(
-    level: VcsLevel, root: PathBuf, repo: Repository, branch_name: String, remote_name: String,
+    level: VcsLevel, root: PathBuf, repo: Repository, branch_name: Option<String>, remote_name: String,
     fetches: RefCell<HashMap<String, Oid>>
   ) -> GitVcsLevel {
     match level {
@@ -746,8 +763,19 @@ fn find_root_blind<P: AsRef<Path>>(path: P) -> Result<PathBuf> {
   }
 }
 
-fn find_remote_name(repo: &Repository, branch_name: &str) -> Result<String> {
-  repo.config()?.get_str(&format!("branch.{}.remote", branch_name)).map(|s| s.to_string()).or_else(|_| {
+fn find_remote_name(repo: &Repository, branch_name: &Option<String>) -> Result<String> {
+  let configured = branch_name
+    .as_ref()
+    .and_then(|branch_name| {
+      repo
+        .config()
+        .map(|config| config.get_str(&format!("branch.{}.remote", branch_name)).map(|s| s.to_string()).ok())
+        .transpose()
+    })
+    .transpose()?
+    .ok_or_else(|| bad!("No configured repo found for {:?}.", branch_name));
+
+  configured.or_else(|_| {
     let remotes = repo.remotes()?;
     if remotes.is_empty() {
       err!("No remotes in this repo.")
@@ -759,16 +787,20 @@ fn find_remote_name(repo: &Repository, branch_name: &str) -> Result<String> {
   })
 }
 
-fn find_branch_name(repo: &Repository) -> Result<String> {
+fn find_branch_name(repo: &Repository) -> Result<Option<String>> {
   let head_ref = repo.find_reference("HEAD").map_err(|e| bad!("Couldn't resolve head: {:?}.", e))?;
   if head_ref.kind() != Some(ReferenceType::Symbolic) {
-    return err!("Not on a branch.");
+    Ok(None)
   } else {
-    let branch_name = head_ref.symbolic_target().ok_or_else(|| bad!("Branch is not named."))?;
-    if branch_name.starts_with("refs/heads/") {
-      Ok(branch_name[11 ..].to_string())
-    } else {
-      return err!("Current {} is not a branch.", branch_name);
+    match head_ref.symbolic_target() {
+      None => Ok(None),
+      Some(branch_name) => {
+        if branch_name.starts_with("refs/heads/") {
+          Ok(Some(branch_name[11 ..].to_string()))
+        } else {
+          return err!("Current {} is not a branch.", branch_name);
+        }
+      }
     }
   }
 }
@@ -959,13 +991,16 @@ fn get_oid_local<'r>(repo: &'r Repository, spec: &str) -> Result<AnnotatedCommit
 }
 
 fn get_oid_remote<'r>(
-  repo: &'r Repository, branch_name: &str, spec: &str, remote_name: &str, fetches: &RefCell<HashMap<String, Oid>>
+  repo: &'r Repository, branch_name: &Option<String>, spec: &str, remote_name: &str,
+  fetches: &RefCell<HashMap<String, Oid>>
 ) -> Result<AnnotatedCommit<'r>> {
   let (commit, cached) = verified_fetch(repo, remote_name, fetches, spec)?;
 
-  if !cached && (spec == branch_name || spec == "HEAD") {
-    info!("Merging to \"{}\" on local.", spec);
-    ff_merge(repo, branch_name, &commit)?;
+  if let Some(branch_name) = branch_name {
+    if !cached && spec == branch_name {
+      info!("Merging to \"{}\" on local.", spec);
+      ff_merge(repo, branch_name, &commit)?;
+    }
   }
   Ok(commit)
 }
diff --git a/src/github.rs b/src/github.rs
index 8095a21..cd450b4 100644
--- a/src/github.rs
+++ b/src/github.rs
@@ -26,10 +26,19 @@ pub fn changes(auth: &Auth, repo: &Repo, baseref: FromTagBuf, headref: String) -
   let mut all_commits = HashSet::new();
   let mut all_prs = HashMap::new();
 
+  let mut discover_order = 0;
   let mut queue = VecDeque::new();
   let offset = FixedOffset::west(0);
-  let pr_zero =
-    FullPr::lookup(repo, baseref, headref.clone(), 0, "".into(), offset.timestamp(Utc::now().timestamp(), 0))?;
+  let pr_zero = FullPr::lookup(
+    repo,
+    baseref,
+    headref.clone(),
+    0,
+    "".into(),
+    offset.timestamp(Utc::now().timestamp(), 0),
+    discover_order
+  )?;
+  discover_order += 1;
   queue.push_back(pr_zero.span().ok_or_else(|| bad!("Unable to get oid for seed ref \"{}\".", headref))?);
   all_prs.insert(pr_zero.number(), pr_zero);
 
@@ -52,10 +61,11 @@ pub fn changes(auth: &Auth, repo: &Repo, baseref: FromTagBuf, headref: String) -
         for pr in prs.merged_only() {
           let number = pr.number();
           if !all_prs.contains_key(&number) {
-            let full_pr = match pr.lookup(repo) {
+            let full_pr = match pr.lookup(repo, discover_order) {
               Ok(pr) => pr,
               Err(e) => return Some(Err(e))
             };
+            discover_order += 1;
             if let Some(span) = full_pr.span() {
               queue.push_back(span);
             }
@@ -240,7 +250,7 @@ struct PrList {
 
 impl PrList {
   fn merged_only(self) -> impl Iterator<Item = PrEdgeNode> {
-    self.edges.into_iter().map(|e| e.node).filter(|n| n.state() == "MERGED")
+    self.edges.into_iter().map(|e| e.node).filter(|n| n.state() == "MERGED" || n.state() == "OPEN")
   }
 }
 
@@ -266,14 +276,15 @@ impl PrEdgeNode {
   pub fn number(&self) -> u32 { self.number }
   pub fn state(&self) -> &str { &self.state }
 
-  pub fn lookup(self, repo: &Repo) -> Result<FullPr> {
+  pub fn lookup(self, repo: &Repo, discover_order: usize) -> Result<FullPr> {
     FullPr::lookup(
       repo,
       FromTagBuf::new(self.base_ref_oid, false),
       self.head_ref_name,
       self.number,
       self.title,
-      self.closed_at
+      self.closed_at,
+      discover_order
     )
   }
 }
@@ -287,7 +298,7 @@ fn deserialize_datetime<'de, D: Deserializer<'de>>(desr: D) -> std::result::Resu
     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str("an RFC 3339 datetime") }
 
     fn visit_str<E: de::Error>(self, v: &str) -> std::result::Result<Self::Value, E> {
-      if v.is_empty() {
+      if v.is_empty() || v.trim() == "null" {
         return self.visit_none();
       }
       DateTime::parse_from_rfc3339(v).map_err(|e| de::Error::custom(format!("Couldn't parse date {}: {:?}", v, e)))
@@ -297,7 +308,9 @@ fn deserialize_datetime<'de, D: Deserializer<'de>>(desr: D) -> std::result::Resu
       let offset = FixedOffset::west(0);
       Ok(offset.timestamp(Utc::now().timestamp(), 0))
     }
+
+    fn visit_unit<E: de::Error>(self) -> std::result::Result<Self::Value, E> { self.visit_none() }
   }
 
-  desr.deserialize_str(DateTimeVisitor)
+  desr.deserialize_any(DateTimeVisitor)
 }
diff --git a/src/mono.rs b/src/mono.rs
index a4380ef..54cbb39 100644
--- a/src/mono.rs
+++ b/src/mono.rs
@@ -53,12 +53,18 @@ impl Mono {
 
   pub fn check_branch(&self) -> std::result::Result<(), (String, String)> {
     if let Ok(branch_name) = self.repo.branch_name() {
-      if let Some(cfg_name) = self.current.branch() {
-        if branch_name != cfg_name {
-          Err((cfg_name.clone(), branch_name.clone()))
+      if let Some(branch_name) = branch_name {
+        if let Some(cfg_name) = self.current.branch() {
+          if branch_name != cfg_name {
+            Err((cfg_name.clone(), branch_name.clone()))
+          } else {
+            Ok(())
+          }
         } else {
           Ok(())
         }
+      } else if let Some(cfg_name) = self.current.branch() {
+        Err((cfg_name.clone(), "((No branch))".to_string()))
       } else {
         Ok(())
       }
@@ -173,8 +179,7 @@ impl Mono {
 
   pub fn changes(&self) -> Result<Changes> {
     let base = FromTagBuf::new(self.current.prev_tag().to_string(), true);
-    let head = self.repo.branch_name()?.to_string();
-    changes(&self.user_prefs.auth, &self.repo, base, head)
+    changes(&self.user_prefs.auth, &self.repo, base, "HEAD".into())
   }
 }
 
@@ -293,7 +298,8 @@ impl Changelog {
 pub struct LoggedPr {
   number: u32,
   title: String,
-  closed_at: DateTime<FixedOffset>,
+  _closed_at: DateTime<FixedOffset>,
+  discovery_order: usize,
   commits: Vec<LoggedCommit>,
   url: Option<String>
 }
@@ -303,7 +309,8 @@ impl LoggedPr {
     LoggedPr {
       number: pr.number(),
       title: pr.title().to_string(),
-      closed_at: *pr.closed_at(),
+      _closed_at: *pr.closed_at(),
+      discovery_order: pr.discovery_order(),
       commits: Vec::new(),
       url
     }
@@ -311,7 +318,8 @@ impl LoggedPr {
 
   pub fn number(&self) -> u32 { self.number }
   pub fn title(&self) -> &str { &self.title }
-  pub fn closed_at(&self) -> &DateTime<FixedOffset> { &self.closed_at }
+  pub fn _closed_at(&self) -> &DateTime<FixedOffset> { &self._closed_at }
+  pub fn discovery_order(&self) -> usize { self.discovery_order }
   pub fn commits(&self) -> &[LoggedCommit] { &self.commits }
   pub fn url(&self) -> &Option<String> { &self.url }
 }
@@ -501,7 +509,7 @@ impl<'s> PlanBuilder<'s> {
 
   pub fn sort_and_dedup(&mut self) -> Result<()> {
     for (.., changelog) in self.incrs.values_mut() {
-      changelog.entries.sort_by_key(|(pr, _)| *pr.closed_at());
+      changelog.entries.sort_by(|(pr1, _), (pr2, _)| pr2.discovery_order().cmp(&pr1.discovery_order()));
 
       let mut seen_commits = HashSet::new();
       for (pr, size) in &mut changelog.entries {
diff --git a/src/output.rs b/src/output.rs
index 37083c7..d960f88 100644
--- a/src/output.rs
+++ b/src/output.rs
@@ -6,6 +6,7 @@ use crate::errors::{Result, ResultExt};
 use crate::github::Changes;
 use crate::mono::{Mono, Plan};
 use crate::state::StateRead;
+use serde_json::json;
 use std::path::PathBuf;
 
 pub struct Output {}
@@ -18,6 +19,7 @@ impl Output {
   pub fn new() -> Output { Output {} }
   pub fn check(&self) -> CheckOutput { CheckOutput::new() }
   pub fn projects(&self, wide: bool, vers_only: bool) -> ProjOutput { ProjOutput::new(wide, vers_only) }
+  pub fn info(&self, show_name: bool, show_root: bool) -> ProjOutput { ProjOutput::info(show_name, show_root) }
   pub fn diff(&self) -> DiffOutput { DiffOutput::new() }
   pub fn files(&self) -> FilesOutput { FilesOutput::new() }
   pub fn changes(&self) -> ChangesOutput { ChangesOutput::new() }
@@ -44,11 +46,20 @@ impl CheckOutput {
 pub struct ProjOutput {
   wide: bool,
   vers_only: bool,
-  proj_lines: Vec<ProjLine>
+  proj_lines: Vec<ProjLine>,
+  info_only: bool,
+  show_name: bool,
+  show_root: bool
 }
 
 impl ProjOutput {
-  pub fn new(wide: bool, vers_only: bool) -> ProjOutput { ProjOutput { wide, vers_only, proj_lines: Vec::new() } }
+  pub fn new(wide: bool, vers_only: bool) -> ProjOutput {
+    ProjOutput { show_name: false, show_root: false, info_only: false, wide, vers_only, proj_lines: Vec::new() }
+  }
+
+  pub fn info(show_name: bool, show_root: bool) -> ProjOutput {
+    ProjOutput { info_only: true, show_name, show_root, wide: false, vers_only: false, proj_lines: Vec::new() }
+  }
 
   pub fn write_projects<I: Iterator<Item = Result<ProjLine>>>(&mut self, lines: I) -> Result<()> {
     self.proj_lines = lines.collect::<Result<_>>()?;
@@ -62,13 +73,35 @@ impl ProjOutput {
 
   pub fn commit(&mut self) -> Result<()> {
     let name_width = self.proj_lines.iter().map(|l| l.name.len()).max().unwrap_or(0);
-    for line in &self.proj_lines {
-      if self.vers_only {
-        println!("{}", line.version);
-      } else if self.wide {
-        println!("{:>6}. {:width$} : {}", line.id, line.name, line.version, width = name_width);
-      } else {
-        println!("{:width$} : {}", line.name, line.version, width = name_width);
+    if self.info_only {
+      let val = json!(self
+        .proj_lines
+        .iter()
+        .map(|line| {
+          let root = line.root.as_deref().unwrap_or(".");
+          if self.show_name {
+            if self.show_root {
+              json!({"name": line.name, "root": root})
+            } else {
+              json!({"name": line.name})
+            }
+          } else if self.show_root {
+            json!({ "root": root })
+          } else {
+            json!({})
+          }
+        })
+        .collect::<Vec<_>>());
+      println!("{}", serde_json::to_string(&val)?);
+    } else {
+      for line in &self.proj_lines {
+        if self.vers_only {
+          println!("{}", line.version);
+        } else if self.wide {
+          println!("{:>6}. {:width$} : {}", line.id, line.name, line.version, width = name_width);
+        } else {
+          println!("{:width$} : {}", line.name, line.version, width = name_width);
+        }
       }
     }
     Ok(())
@@ -78,7 +111,8 @@ impl ProjOutput {
 pub struct ProjLine {
   pub id: ProjectId,
   pub name: String,
-  pub version: String
+  pub version: String,
+  pub root: Option<String>
 }
 
 impl ProjLine {
@@ -86,7 +120,8 @@ impl ProjLine {
     let id = p.id();
     let name = p.name().to_string();
     let version = p.get_value(read)?;
-    Ok(ProjLine { id: id.clone(), name, version })
+    let root = p.root().cloned();
+    Ok(ProjLine { id: id.clone(), name, version, root })
   }
 }