--- a/launcher/src/main/java/com/redhat/thermostat/launcher/internal/TabCompletion.java	Tue Jun 23 10:46:29 2015 -0400
+++ b/launcher/src/main/java/com/redhat/thermostat/launcher/internal/TabCompletion.java	Wed Jun 24 10:51:15 2015 -0400
@@ -60,6 +60,8 @@
         }
 
         TreeCompleter treeCompleter = new TreeCompleter();
+        treeCompleter.setAlphabeticalCompletions(true);
+
         for (CommandInfo info : commandInfoSource.getCommandInfos()) {
 
             if (info.getEnvironments().contains(Environment.SHELL)) {

--- a/launcher/src/main/java/com/redhat/thermostat/launcher/internal/TreeCompleter.java	Tue Jun 23 10:46:29 2015 -0400
+++ b/launcher/src/main/java/com/redhat/thermostat/launcher/internal/TreeCompleter.java	Wed Jun 24 10:51:15 2015 -0400
@@ -43,6 +43,8 @@
 
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
 import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.List;
@@ -58,6 +60,7 @@
 
     private Node currentNode;
     private ArgumentList list;
+    private boolean alphabeticalSortingEnabled = false;
 
     public static final int NOT_FOUND = -1;
     private static final String EMPTY_SPACE = " ";
@@ -94,6 +97,21 @@
     }
 
     /**
+     * Sets whether the completions returned by the completer will be alphabetical
+     * @param completeAlphabetically true will result in alphabetically sorted completions
+     */
+    public void setAlphabeticalCompletions(boolean completeAlphabetically) {
+        alphabeticalSortingEnabled = completeAlphabetically;
+    }
+
+    /**
+     * @return whether the completer will be alphabetically sorted
+     */
+    public boolean isAlphabeticalSortingEnabled() {
+        return alphabeticalSortingEnabled;
+    }
+
+    /**
      * This method is called when attempting to tab complete
      * @param buffer the input that will be tab completed
      * @param cursorPosition the position of the cursorPosition within the buffer
@@ -133,9 +151,22 @@
             }
         }
 
+        if (alphabeticalSortingEnabled) {
+            inplaceSortAlphabetically(candidates);
+        }
+
         return position;
     }
 
+    private void inplaceSortAlphabetically(List<CharSequence> candidates) {
+        Collections.sort(candidates, new Comparator<CharSequence>() {
+            @Override
+            public int compare(final CharSequence t0, final CharSequence t1) {
+                return t0.toString().compareTo(t1.toString());
+            }
+        });
+    }
+
     private int getInlinedCursorPosition(final Completer completer, final List<CharSequence> candidates) {
         int cursor = completer.complete(list.getCursorArgument(), list.getArgumentPosition(), candidates);
         return cursor + list.getBufferPosition() - list.getArgumentPosition();

--- a/launcher/src/test/java/com/redhat/thermostat/launcher/internal/TreeCompleterTest.java	Tue Jun 23 10:46:29 2015 -0400
+++ b/launcher/src/test/java/com/redhat/thermostat/launcher/internal/TreeCompleterTest.java	Wed Jun 24 10:51:15 2015 -0400
@@ -333,6 +333,81 @@
         assertTrue(convertedCandidates.isEmpty());
     }
 
+    @Test
+    public void testAlphabeticalOrder() {
+        tree.setAlphabeticalCompletions(true);
+
+        List<String> output = completeBuffer("");
+
+        assertEquals(4, output.size());
+        assertTrue(output.get(0).equals("anotherCommand"));
+        assertTrue(output.get(1).equals("command1"));
+        assertTrue(output.get(2).equals("command2"));
+        assertTrue(output.get(3).equals("otherCommand"));
+    }
+
+    @Test
+    public void testAlphabeticalOrderForOptions() {
+        tree.setAlphabeticalCompletions(true);
+
+        List<String> output = completeBuffer("otherCommand list ");
+
+        assertEquals(5 ,output.size());
+        assertTrue(output.get(0).equals("assemblies"));
+        assertTrue(output.get(1).equals("bolts"));
+        assertTrue(output.get(2).equals("degreesOfFreedom"));
+        assertTrue(output.get(3).equals("parts"));
+        assertTrue(output.get(4).equals("tools"));
+    }
+
+    @Test
+    public void testAlphabeticalOrderNotSetToTrue() {
+        tree.setAlphabeticalCompletions(false);
+
+        List<String> output = completeBuffer("");
+
+        assertEquals(4 ,output.size());
+        assertFalse(output.get(0).equals("anotherCommand"));
+        assertFalse(output.get(1).equals("command1"));
+        assertFalse(output.get(2).equals("command2"));
+        assertFalse(output.get(3).equals("otherCommand"));
+    }
+
+    @Test
+    public void testAlphabeticalOrderForInlineOptions() {
+        tree.setAlphabeticalCompletions(true);
+
+        List<String> output = completeBuffer("anotherCommand grab dri");
+
+        assertEquals(12 ,output.size());
+        assertTrue(output.get(0).equals("drink-apple-juice"));
+        assertTrue(output.get(1).equals("drink-apple-soda"));
+        assertTrue(output.get(2).equals("drink-banana-juice"));
+        assertTrue(output.get(3).equals("drink-coke"));
+        assertTrue(output.get(4).equals("drink-fanta"));
+        assertTrue(output.get(5).equals("drink-grape-soda"));
+        assertTrue(output.get(6).equals("drink-orange-juice"));
+        assertTrue(output.get(7).equals("drink-pepsi"));
+        assertTrue(output.get(8).equals("drink-pepsi-diet"));
+        assertTrue(output.get(9).equals("drink-pepsi-lime"));
+        assertTrue(output.get(10).equals("drink-pepsi-vanilla"));
+        assertTrue(output.get(11).equals("drink-pepsi-zero"));
+    }
+
+    @Test
+    public void testAlphabeticalOrderForFurtherInlinedOptions() {
+        tree.setAlphabeticalCompletions(true);
+
+        List<String> output = completeBuffer("anotherCommand grab drink-pep");
+
+        assertEquals(5 ,output.size());
+        assertTrue(output.get(0).equals("drink-pepsi"));
+        assertTrue(output.get(1).equals("drink-pepsi-diet"));
+        assertTrue(output.get(2).equals("drink-pepsi-lime"));
+        assertTrue(output.get(3).equals("drink-pepsi-vanilla"));
+        assertTrue(output.get(4).equals("drink-pepsi-zero"));
+    }
+
     private List<String> completeBuffer(String buffer) {
         return completeBuffer(buffer, buffer.length());
     }
@@ -469,6 +544,35 @@
                 list.addBranch(twentyFifthToSeventyFifthPart);
             }
             anotherCommand.addBranch(list);
+
+            TreeCompleter.Node grab = createStringNode("grab");
+            {
+                TreeCompleter.Node pepsi = createStringNode("drink-pepsi");
+                TreeCompleter.Node coke = createStringNode("drink-coke");
+                TreeCompleter.Node fanta = createStringNode("drink-fanta");
+                TreeCompleter.Node apple = createStringNode("drink-apple-juice");
+                TreeCompleter.Node banana = createStringNode("drink-banana-juice");
+                TreeCompleter.Node orange = createStringNode("drink-orange-juice");
+                TreeCompleter.Node appleSoda = createStringNode("drink-apple-soda");
+                TreeCompleter.Node grapeSoda = createStringNode("drink-grape-soda");
+                TreeCompleter.Node pepsiZero = createStringNode("drink-pepsi-zero");
+                TreeCompleter.Node pepsiDiet = createStringNode("drink-pepsi-diet");
+                TreeCompleter.Node pepsiVanilla = createStringNode("drink-pepsi-vanilla");
+                TreeCompleter.Node pepsiLime = createStringNode("drink-pepsi-lime");
+                grab.addBranch(pepsi);
+                grab.addBranch(coke);
+                grab.addBranch(fanta);
+                grab.addBranch(apple);
+                grab.addBranch(banana);
+                grab.addBranch(orange);
+                grab.addBranch(appleSoda);
+                grab.addBranch(grapeSoda);
+                grab.addBranch(pepsiZero);
+                grab.addBranch(pepsiDiet);
+                grab.addBranch(pepsiVanilla);
+                grab.addBranch(pepsiLime);
+            }
+            anotherCommand.addBranch(grab);
         }
 
         commands.add(command1);