roadmap of commands

[joyously]

Is there a documented roadmap for jj, like a list of all commands intended? How do you judge your progress?
Will there be a blame (or credit) command?
How about tags?
How about bisect or grep?

JJ

When I do jj help, I get an uneven list that seems to have a random order.

Commands:
  version
          Display version information
  init
          Create a new repo in the given directory
  config
          Manage config options
  checkout
          Create a new, empty change and edit it in the working copy [aliases: co]
  untrack
          Stop tracking specified paths in the working copy
  files
          List files in a revision
  cat
          Print contents of a file in a revision
  diff
          Show changes in a revision
  show
          Show commit description and changes in a revision
  status
          Show high-level repo status [aliases: st]
  log
          Show commit history
  obslog
          Show how a change has evolved
  interdiff
          Compare the changes of two commits
  describe
          Edit the change description
  duplicate
          Create a new change with the same content as an existing one
  abandon
          Abandon a revision [aliases: hide]
  edit
          Edit a commit in the working copy
  new
          Create a new, empty change and edit it in the working copy
  move
          Move changes from one revision into another
  squash
          Move changes from a revision into its parent [aliases: amend]
  unsquash
          Move changes from a revision's parent into the revision [aliases: unamend]
  restore
          Restore paths from another revision
  diffedit
          Touch up the content changes in a revision with a diff editor
  resolve
          Resolve a conflicted file with an external merge tool
  split
          Split a revision in two
  merge
          Merge work from multiple branches
  rebase
          Move revisions to different parent(s)
  backout
          Apply the reverse of a revision on top of another revision
  branch
          Manage branches
  undo
          Undo an operation (shortcut for `jj op undo`)
  operation
          Commands for working with the operation log [aliases: op]
  workspace
          Commands for working with workspaces
  sparse
          Manage which paths from the working-copy commit are present in the working copy
  git
          Commands for working with the underlying Git repo
  help
          Print this message or the help of the given subcommand(s)

Git

Git shows an alphabetical list of commands, by porcelain and then others.

Main Porcelain Commands
   add                  Add file contents to the index
   am                   Apply a series of patches from a mailbox
   archive              Create an archive of files from a named tree
   bisect               Use binary search to find the commit that introduced a bug
   branch               List, create, or delete branches
   bundle               Move objects and refs by archive
   checkout             Switch branches or restore working tree files
   cherry-pick          Apply the changes introduced by some existing commits
   citool               Graphical alternative to git-commit
   clean                Remove untracked files from the working tree
   clone                Clone a repository into a new directory
   commit               Record changes to the repository
   describe             Give an object a human readable name based on an available ref
   diff                 Show changes between commits, commit and working tree, etc
   fetch                Download objects and refs from another repository
   format-patch         Prepare patches for e-mail submission
   gc                   Cleanup unnecessary files and optimize the local repository
   gitk                 The Git repository browser
   grep                 Print lines matching a pattern
   gui                  A portable graphical interface to Git
   init                 Create an empty Git repository or reinitialize an existing one
   log                  Show commit logs
   maintenance          Run tasks to optimize Git repository data
   merge                Join two or more development histories together
   mv                   Move or rename a file, a directory, or a symlink
   notes                Add or inspect object notes
   pull                 Fetch from and integrate with another repository or a local branch
   push                 Update remote refs along with associated objects
   range-diff           Compare two commit ranges (e.g. two versions of a branch)
   rebase               Reapply commits on top of another base tip
   reset                Reset current HEAD to the specified state
   restore              Restore working tree files
   revert               Revert some existing commits
   rm                   Remove files from the working tree and from the index
   shortlog             Summarize 'git log' output
   show                 Show various types of objects
   sparse-checkout      Initialize and modify the sparse-checkout
   stash                Stash the changes in a dirty working directory away
   status               Show the working tree status
   submodule            Initialize, update or inspect submodules
   switch               Switch branches
   tag                  Create, list, delete or verify a tag object signed with GPG
   worktree             Manage multiple working trees

Breezy

Here is a list from brz help commands, which is alphabetical and easier to read, (but long).

add                          Add specified files or directories.
alias                        Set/unset and display aliases.
annotate                     Show the origin of each line in a file.
bash-completion              Generate a shell function for bash command line completion.
                             [bash_completion]
bind                         Convert the current branch into a checkout of the supplied branch.
bisect                       Find an interesting commit using a binary search.
branch                       Create a new branch that is a copy of an existing branch.
branches                     List the branches available at the current location.
break-lock                   Break a dead lock.
cat                          Write the contents of a file as of a given revision to standard
                             output.
check                        Validate working tree structure, branch consistency and repository
                             history.
checkout                     Create a new checkout of an existing branch.
clean-tree                   Remove unwanted files from working tree.
clone                        Clone a control directory.
commit                       Commit changes into a new revision.
committer-statistics         Generate statistics for LOCATION. [stats]
config                       Display, set or remove a configuration option.
conflicts                    List files with conflicts.
cp                           Copy a file.
credits                      Determine credits for LOCATION. [stats]
deleted                      List files deleted in the working tree.
diff                         Show differences in the working tree, between revisions or branches.
export                       Export current or past revision to a destination directory or archive.
fast-export                  Generate a fast-import stream from a Bazaar branch. [fastimport]
fast-import                  Backend for fast Bazaar data importers. [fastimport]
find-merge-proposal          Find a merge proposal. [propose]
git-apply                    Apply a series of git-am style patches.
git-import                   Import all branches from a git repository.
git-push-pristine-tar-deltas Push pristine tar deltas to a git repository.
github-login                 Log into GitHub. [github]
gitlab-login                 Log into a GitLab instance. [gitlab]
grep                         Print lines matching PATTERN for specified files and revisions.
help                         Show help on a command or other topic.
ignore                       Ignore specified files or patterns.
ignored                      List ignored files and the patterns that matched them.
import                       Import sources from a directory, tarball or zip file
info                         Show information about a working tree, branch or repository.
init                         Make a directory into a versioned branch.
init-shared-repository       Create a shared repository for branches to share storage space.
join                         Combine a tree into its containing tree.
land-merge-proposal          Land a merge proposal. [propose]
launchpad-login              Show or set the Launchpad user ID. [launchpad]
launchpad-logout             Unset the Launchpad user ID. [launchpad]
launchpad-open               Open a Launchpad branch page in your web browser. [launchpad]
link-tree                    Hardlink matching files to another tree.
log                          Show historical log for a branch or subset of a branch.
lp-find-proposal             Find the proposal to merge this revision. [launchpad]
ls                           List files in a tree.
merge                        Perform a three-way merge.
missing                      Show unmerged/unpulled revisions between two branches.
mkdir                        Create a new versioned directory.
mv                           Move or rename a file.
nick                         Print or set the branch nickname.
pack                         Compress the data within a repository.
patch                        Apply a named patch to the current tree.
ping                         Pings a Bazaar smart server.
plugins                      List the installed plugins.
propose-merge                Propose a branch for merging. [propose]
publish-derived              Publish a derived branch. [propose]
pull                         Turn this branch into a mirror of another branch.
push                         Update a mirror of this branch.
rebase                       Re-base a branch. [rewrite]
rebase-abort                 Abort an interrupted rebase. [rewrite]
rebase-continue              Continue an interrupted rebase after resolving conflicts. [rewrite]
rebase-foreign               Rebase revisions based on a branch created with a different import
                             tool. [rewrite]
rebase-todo                  Print list of revisions that still need to be replayed as part of the
                             [rewrite]
reconcile                    Reconcile brz metadata in a branch.
reconfigure                  Reconfigure the type of a brz directory.
remerge                      Redo a merge.
remove                       Remove files or directories.
remove-branch                Remove a branch.
remove-tree                  Remove the working tree from a given branch/checkout.
renames                      Show list of renamed files.
resolve                      Mark a conflict as resolved.
revert                       Set files in the working tree back to the contents of a previous
                             revision.
revno                        Show current revision number.
root                         Show the tree root directory.
send                         Mail or create a merge-directive for submitting changes.
serve                        Run the brz server.
shelve                       Temporarily set aside some changes from the current tree.
sign-my-commits              Sign all commits by a given committer.
split                        Split a subdirectory of a tree into a separate tree.
status                       Display status summary.
switch                       Set the branch of a checkout and update.
tag                          Create, remove or modify a tag naming a revision.
tags                         List tags.
testament                    Show testament (signing-form) of a revision.
unbind                       Convert the current checkout into a regular branch.
uncommit                     Remove the last committed revision.
unshelve                     Restore shelved changes.
update                       Update a working tree to a new revision.
upgrade                      Upgrade a repository, branch or working tree to a newer format.
upload                       Upload a working tree, as a whole or incrementally. [upload]
verify-signatures            Verify all commit signatures.
version                      Show version of brz.
version-info                 Show version information about this tree.
view                         Manage filtered views.
whoami                       Show or set brz user id.
zsh-completion               Generate a shell function for zsh command line completion.
                             [zsh_completion]

Darcs

Darcs has a RosettaSone page you might find interesting.
The command darcs help shows

Most used/starting out:
  initialize      Create an empty repository.
  add             Add new files to version control.
  whatsnew        List unrecorded changes in the working tree.
  record          Create a patch from unrecorded changes.
  clone           Make a copy of an existing repository.
  pull            Copy and apply patches from another repository to this one.
  push            Copy and apply patches from this repository to another one.

Preparing patches before recording:
  move            Move or rename files.
  remove          Remove files from version control.
  replace         Substitute one word for another.

Querying the repository:
  log             List patches in the repository.
  annotate        Annotate lines of a file with the last patch that modified it.
  diff            Create a diff between two versions of the repository.
  show            Show information about the given repository.
  test            Run tests and search for the patch that introduced a bug.

Undoing and correcting:
  revert          Discard unrecorded changes.
  unrevert        Undo the last revert.
  amend           Improve a patch before it leaves your repository.
  rebase          Edit several patches at once.
  rollback        Apply the inverse of recorded changes to the working tree.
  unrecord        Remove recorded patches without changing the working tree.
  obliterate      Delete selected patches from the repository.

Direct modification of the repository:
  tag             Name the current repository state for future reference.
  setpref         Set a preference (test, predist, boringfile, or binariesfile).

Exchanging patches by e-mail:
  send            Prepare a bundle of patches to be applied to some target repository.
  apply           Apply a patch bundle created by `darcs send'.

Other commands:
  optimize        Optimize the repository.
  dist            Create a distribution archive.
  mark-conflicts  Mark unresolved conflicts in working tree, for manual resolution.
  repair          Repair a corrupted repository.
  convert         Convert repositories between various formats.
  fetch           Fetch patches from another repository, but don't apply them.

[martinvonz]

Is there a documented roadmap for jj, like a list of all commands intended?

There's no documented roadmap.

How do you judge your progress?

I think I mostly do that by looking at the changelog :) See the changelog for 0.7.0 (the most recent release), for example.

Will there be a blame (or credit) command?
How about tags?
How about bisect or grep?

Yes, we should eventually get all of those. Other commands I know we're planning to add are:

• jj run/test/fix for running commands (like tests or formatting) on a set of specified commits.
• jj sync for pulling/fetching and rebasing/merging (like git pull)
• Some command for reordering commits. I don't know if that will be something like git rebase -i or more like git-branchless's git move --extract --insert.
• Some command for running GC and repacking and maybe other repo maintenance

When I do jj help, I get an uneven list that seems to have a random order.

Hmm, I'm surprised I had never noticed that before. I've sent #1344 for using alphabetical order for now. I agree that we should group the commands in some logical way, but that seems to be a lot of work until clap adds support for that.

Darcs has a RosettaSone page you might find interesting.

Thanks for sharing. The closest we have is our Git-comparison doc.