--- a/bin/piston
+++ b/bin/piston
@@ -7,6 +7,4 @@ rescue LoadError
 end
 
 require 'piston'
-require 'piston/ui/command_line'
-
-Piston::Ui::CommandLine.start
+PistonCommandLineProcessor.parse_and_execute

--- a/lib/piston.rb
+++ b/lib/piston.rb
@@ -30,6 +30,13 @@ Dir[File.join(PISTON_ROOT, 'core_ext', '*.rb')].each do |file|
   require file
 end
 
+require "piston/version"
+require File.join(PISTON_ROOT, "transat", "parser")
+require File.join(PISTON_ROOT, 'piston', 'command')
+Dir[File.join(PISTON_ROOT, "piston", "commands", "*.rb")].each do |file|
+  require file.gsub(PISTON_ROOT, "")[1..-4]
+end
+
 module Piston
   ROOT        = "piston:root"
   UUID        = "piston:uuid"
@@ -38,6 +45,23 @@ module Piston
   LOCKED      = "piston:locked"
 end
 
-require File.join(PISTON_ROOT, 'piston', 'command')
-require File.join(PISTON_ROOT, 'piston', 'command_error')
-require File.join(PISTON_ROOT, 'piston', 'ui', 'command_line')
+PistonCommandLineProcessor = Transat::Parser.new do
+  program_name "Piston"
+  version [Piston::VERSION::STRING]
+
+  option :verbose, :short => :v, :default => true, :message => "Show subversion commands and results as they are executed"
+  option :quiet, :short => :q, :default => false, :message => "Do not output any messages except errors"
+  option :revision, :short => :r, :param_name => "REVISION", :type => :int
+  option :show_updates, :short => :u, :message => "Query the remote repository for out of dateness information"
+  option :lock, :short => :l, :message => "Close down and lock the imported directory from further changes"
+  option :dry_run, :message => "Does not actually execute any commands"
+  option :force, :message => "Force the command to run, even if Piston thinks it would cause a problem"
+
+  command :switch, Piston::Commands::Switch, :valid_options => %w(lock dry_run force revision quiet verbose)
+  command :update, Piston::Commands::Update, :valid_options => %w(lock dry_run force revision quiet verbose)
+  command :import, Piston::Commands::Import, :valid_options => %w(lock dry_run force revision quiet verbose)
+  command :convert, Piston::Commands::Convert, :valid_options => %w(lock verbose dry_run)
+  command :unlock, Piston::Commands::Unlock, :valid_options => %w(force dry_run verbose)
+  command :lock, Piston::Commands::Lock, :valid_options => %w(force dry_run revision verbose)
+  command :status, Piston::Commands::Status, :valid_options => %w(show_updates verbose)
+end

--- a/lib/piston/command.rb
+++ b/lib/piston/command.rb
@@ -2,7 +2,16 @@ module Piston
   # The base class which all commands subclass to obtain services from.
   class Command
     attr_accessor :revision, :dry_run, :quiet, :verbose, :force, :lock,
-                  :recursive, :logging_stream, :show_updates
+                  :recursive, :show_updates
+    attr_reader :args
+    attr_writer :logging_stream
+
+    def initialize(non_options, options)
+      @args = non_options
+      options.each do |option, value|
+        self.send("#{option}=", value)
+      end
+    end
 
     # Execute this command.  The arguments are pre-processed to expand any
     # wildcards using Dir#[].  This is because the Windows shell does not

--- a/lib/piston/commands/convert.rb
+++ b/lib/piston/commands/convert.rb
@@ -3,7 +3,7 @@ require 'piston/commands/import'
 module Piston
   module Commands
     class Convert < Piston::Command
-      def run(args)
+      def run
         if args.empty? then
           svn(:propget, '--recursive', 'svn:externals').each_line do |line|
             next unless line =~ /^([^ ]+)\s-\s/
@@ -65,24 +65,14 @@ module Piston
         "Converts existing svn:externals into Piston managed folders"
       end
 
-      def self.detailed_help(stream)
-        stream.puts <<EOF
-convert: #{help}
+      def self.detailed_help
+        <<EOF
 usage: convert [DIR [...]]
 
   Converts folders which have the svn:externals property set to Piston managed 
   folders.
-
-  Valid options:
-      --verbose             : Show Subversion commands and results as they
-                              are executed
-
 EOF
       end
-
-      def self.aliases
-        %w(convert)
-      end
     end
   end
 end

--- a/lib/piston/commands/help.rb
+++ /dev/null
@@ -1,44 +0,0 @@
-module Piston
-  module Commands
-    class Help < Piston::Command
-      def run(targets=nil)
-        command = targets.shift
-
-        return help_on_command(command) if command
-        general_help
-      end
-
-      def help_on_command(command_name)
-        begin
-          require File.join(PISTON_ROOT, 'piston', 'commands', command_name)
-          command = Piston::Commands.const_get(command_name.capitalize)
-          command.detailed_help(logging_stream)
-        rescue LoadError
-          logging_stream.puts "No help available for '#{command_name}'"
-          general_help
-        end
-      end
-
-      def general_help
-        logging_stream.puts "Available commands are:"
-        commands = Array.new
-        Dir[File.join(PISTON_ROOT, 'piston', 'commands', '*.rb')].each do |file|
-          require file
-          commands << Piston::Commands.const_get(File.basename(file).gsub(/\.rb$/, '').capitalize)
-        end
-
-        commands.each do |command|
-          logging_stream.printf "  %-12s %s\n", command.aliases.first, command.help
-        end
-      end
-
-      def self.help
-        "Returns detailed help on a specific command"
-      end
-
-      def self.aliases
-        %w(help)
-      end
-    end
-  end
-end

--- a/lib/piston/commands/import.rb
+++ b/lib/piston/commands/import.rb
@@ -1,7 +1,7 @@
 module Piston
   module Commands
     class Import < Piston::Command
-      def run(args)
+      def run
         raise Piston::CommandError, "Missing REPOS_URL argument" if args.empty?
 
         repos, dir = args.shift, args.shift
@@ -53,28 +53,19 @@ module Piston
         "Prepares a folder for merge tracking"
       end
 
-      def self.detailed_help(stream)
-        stream.puts <<EOF
-import (init): #{help}
+      def self.detailed_help
+        <<EOF
 usage: import REPOS_URL [DIR]
 
   Exports the specified REPOS_URL (which must be a Subversion repository) to
   DIR, defaulting to the last component of REPOS_URL if DIR is not present.
 
   If the local folder already exists, this command will abort with an error.
-
-  Valid options:
-      -r [--revision] arg   : Start merge tracking at ARG instead of HEAD
-      --lock                : Close down and lock the folder from future
-                              updates immediately
-      --verbose             : Show Subversion commands and results as they
-                              are executed
-
 EOF
       end
 
       def self.aliases
-        %w(import init)
+        %w(init)
       end
     end
   end

--- a/lib/piston/commands/lock.rb
+++ b/lib/piston/commands/lock.rb
@@ -1,7 +1,7 @@
 module Piston
   module Commands
     class Lock < Piston::Command
-      def run(args)
+      def run
         raise Piston::CommandError, "No targets to run against" if args.empty?
 
         args.each do |dir|
@@ -15,23 +15,13 @@ module Piston
         "Lock one or more folders to their current revision"
       end
 
-      def self.detailed_help(stream)
-        stream.puts <<EOF
-lock: #{help}
+      def self.detailed_help
+        <<EOF
 usage: lock DIR [DIR [...]]
 
   Locked folders will not be updated to the latest revision when updating.
-
-  Valid options:
-      --verbose             : Show Subversion commands and results as they
-                              are executed
-
 EOF
       end
-
-      def self.aliases
-        %w(lock)
-      end
     end
   end
 end

--- a/lib/piston/commands/status.rb
+++ b/lib/piston/commands/status.rb
@@ -3,7 +3,7 @@ require 'pp'
 module Piston
   module Commands
     class Status < Piston::Command
-      def run(args)
+      def run
         # First, find the list of pistoned folders
         folders = svn(:propget, '--recursive', Piston::ROOT, *args)
         repos = Hash.new
@@ -49,9 +49,8 @@ module Piston
         "Determines the current status of each pistoned directory"
       end
 
-      def self.detailed_help(stream)
-        stream.puts <<EOF
-status: #{help}
+      def self.detailed_help
+        <<EOF
 usage: status [DIR [DIR...]]
 
   Shows the status of one, many or all pistoned folders.  The status is
@@ -63,16 +62,11 @@ usage: status [DIR [DIR...]]
 
   The second column's values are blanks, unless the --show-updates is passed.
     M:  Remotely modified since importing
-
-  Valid options:
-      --show-updates        : Queries the remote repositories to determine
-                              if they have been updated from our revision.
-
 EOF
       end
 
       def self.aliases
-        %w(status st)
+        %w(st)
       end
     end
   end

--- a/lib/piston/commands/switch.rb
+++ b/lib/piston/commands/switch.rb
@@ -1,7 +1,7 @@
 module Piston
   module Commands
     class Switch < Piston::Command
-      def run(args)
+      def run
         new_root, dir = args.shift, args.shift
         raise Piston::CommandError, "Expected two arguments only to switch.  Unrecognized arguments: #{args.inspect}" unless args.empty?
         switch(dir, new_root)
@@ -113,9 +113,8 @@ module Piston
         "Switches a single directory to a new repository root"
       end
 
-      def self.detailed_help(stream)
-        stream.puts <<EOF
-switch: #{help}
+      def self.detailed_help
+        <<EOF
 usage: switch NEW_REPOSITORY_ROOT DIR
 
   This operation changes the remote location from A to B, keeping local
@@ -126,19 +125,11 @@ usage: switch NEW_REPOSITORY_ROOT DIR
   Piston will refuse to update a folder if it has pending updates.  Run
   'svn update' on the target folder to update it before running Piston
   again.
-
-    Valid options:
-      -r [--revision] arg   : Update to ARG instead of HEAD
-      --lock                : Close down and lock the folder from future
-                              updates immediately
-      --verbose             : Show Subversion commands and results as they
-                              are executed
-
 EOF
       end
 
       def self.aliases
-        %w(switch sw)
+        %w(sw)
       end
     end
   end

--- a/lib/piston/commands/unlock.rb
+++ b/lib/piston/commands/unlock.rb
@@ -1,7 +1,7 @@
 module Piston
   module Commands
     class Unlock < Piston::Command
-      def run(args)
+      def run
         raise Piston::CommandError, "No targets to run against" if args.empty?
         svn :propdel, Piston::LOCKED, *args
         args.each do |dir|
@@ -13,24 +13,14 @@ module Piston
         "Undoes the changes enabled by lock"
       end
 
-      def self.detailed_help(stream)
-        stream.puts <<EOF
-unlock: #{help}
+      def self.detailed_help
+        <<EOF
 usage: unlock DIR [DIR [...]]
 
   Unlocked folders are free to be updated to the latest revision when
   updating.
-
-  Valid options:
-      --verbose             : Show Subversion commands and results as they
-                              are executed
-
 EOF
       end
-
-      def self.aliases
-        %w(unlock)
-      end
     end
   end
 end

--- a/lib/piston/commands/update.rb
+++ b/lib/piston/commands/update.rb
@@ -3,7 +3,7 @@ require 'find'
 module Piston
   module Commands
     class Update < Piston::Command
-      def run(args)
+      def run
         (args.empty? ? find_targets : args).each do |dir|
           update dir
         end
@@ -121,9 +121,8 @@ module Piston
         "Updates all or specified folders to the latest revision"
       end
 
-      def self.detailed_help(stream)
-        stream.puts <<EOF
-update: #{help}
+      def self.detailed_help
+        <<EOF
 usage: update [DIR [...]]
 
   This operation has the effect of downloading all remote changes back to our
@@ -134,19 +133,11 @@ usage: update [DIR [...]]
   Piston will refuse to update a folder if it has pending updates.  Run
   'svn update' on the target folder to update it before running Piston
   again.
-
-    Valid options:
-      -r [--revision] arg   : Update to ARG instead of HEAD
-      --lock                : Close down and lock the folder from future
-                              updates immediately
-      --verbose             : Show Subversion commands and results as they
-                              are executed
-
 EOF
       end
 
       def self.aliases
-        %w(update up)
+        %w(up)
       end
     end
   end

--- a/lib/piston/ui/command_line.rb
+++ /dev/null
@@ -1,72 +0,0 @@
-require 'getoptlong'
-
-module Piston
-  module Ui
-    module CommandLine
-      def self.start
-        opts = ::GetoptLong.new(
-          [ '--revision', '-r', GetoptLong::REQUIRED_ARGUMENT ],
-          [ '--help', '-h', GetoptLong::NO_ARGUMENT ],
-          [ '--dry-run', GetoptLong::NO_ARGUMENT ],
-          [ '--quiet', '-q', GetoptLong::NO_ARGUMENT ],
-          [ '--verbose', '-v', GetoptLong::NO_ARGUMENT ],
-          [ '--show-updates', '-u', GetoptLong::NO_ARGUMENT ],
-          [ '--lock', GetoptLong::NO_ARGUMENT ],
-          [ '--force', '-f', GetoptLong::NO_ARGUMENT ],
-          [ '--version', GetoptLong::NO_ARGUMENT ]
-        )
-
-        options = Hash.new
-
-        opts.each do |opt, arg|
-          case opt
-          when '--revision'
-            options[:revision] = arg.to_i
-
-          when '--help'
-            return help
-
-          when '--version'
-            require 'piston/version'
-            puts "Piston #{Piston::VERSION::STRING}"
-            puts "Copyright 2006, Francois Beausoleil"
-            puts "\nSee the LICENSE file for details"
-            exit
-
-          when /--([-\w]+)$/
-            options[$1.gsub('-', '_').to_sym] = true
-          end
-        end
-
-        return help if ARGV.empty?
-
-        command_name = ARGV.shift.downcase
-        begin
-          require File.join(PISTON_ROOT, 'piston', 'commands', command_name)
-        rescue LoadError
-          return help
-        end
-
-        command_class = Piston::Commands.const_get("#{command_name.capitalize}")
-        command = command_class.new
-        options.each do |key, value|
-          command.send "#{key}=", value
-        end
-
-        begin
-          command.execute(ARGV)
-        rescue Piston::CommandError
-          $stderr.puts "ERROR: #{$!.message}"
-          exit 1
-        end
-      end
-
-      def self.help
-        require File.join(PISTON_ROOT, 'piston', 'commands', 'help')
-        Piston::Commands::Help.new.run(ARGV)
-      end
-    end
-  end
-end
-
-Piston::Ui::CommandLine.start if $0 == __FILE__

--- /dev/null
+++ b/lib/transat/parser.rb
@@ -0,0 +1,189 @@
+require "optparse"
+
+module Transat
+  class VersionNeeded < StandardError; end
+
+  class HelpNeeded < StandardError
+    attr_reader :command
+
+    def initialize(command)
+      @command = command
+    end
+  end
+
+  class NoCommandGiven < StandardError
+    def message
+      "No command given"
+    end
+  end
+
+  class UnknownOptions < StandardError
+    attr_reader :command
+
+    def initialize(command, unrecognized_options)
+      @command, @unrecognized_options = command, unrecognized_options
+    end
+
+    def message
+      "Command #{@command} does not accept options #{@unrecognized_options.join(", ")}"
+    end
+  end
+
+  class UnknownCommand < StandardError
+    def initialize(command, parser)
+      @command, @parser = command, parser
+    end
+
+    def message
+      "Unknown command: #{@command.inspect}"
+    end
+  end
+
+  class BaseCommand
+    attr_reader :non_options, :options
+    def initialize(non_options, options)
+      @non_options, @options = non_options, options
+    end
+  end
+
+  class VersionCommand < BaseCommand
+    def run
+      raise VersionNeeded
+    end
+  end
+
+  class HelpCommand < BaseCommand
+    def run
+      raise HelpNeeded.new(non_options.first)
+    end
+  end
+
+  class Parser
+    def initialize(&block)
+      @valid_options, @received_options, @commands = [], {}, {}
+      @option_parser = OptionParser.new
+
+      command(:help, Transat::HelpCommand)
+      command(:version, Transat::VersionCommand)
+      instance_eval(&block) if block_given?
+    end
+
+    def option(name, options={})
+      options[:long] = name.to_s.gsub("_", "-") unless options[:long]
+      @valid_options << name
+      @received_options[name] = nil
+
+      opt_args = []
+      opt_args << "-#{options[:short]}" if options.has_key?(:short)
+      opt_args << "--#{options[:long] || name}"
+      opt_args << "=#{options[:param_name]}" if options.has_key?(:param_name)
+      opt_args << options[:message]
+      case options[:type]
+      when :int, :integer
+        opt_args << Integer
+      when :float
+        opt_args << Float
+      when nil
+        # NOP
+      else
+        raise ArgumentError, "Option #{name} has a bad :type parameter: #{options[:type].inspect}"
+      end
+
+      @option_parser.on(*opt_args.compact) do |value|
+        @received_options[name] = value
+      end
+    end
+
+    def command(name, klass, options={})
+      @commands[name.to_s] = options.merge(:class => klass)
+    end
+
+    def parse_and_execute(args=ARGV)
+      begin
+        command, non_options = parse(args)
+        execute(command, non_options)
+      rescue HelpNeeded
+        $stderr.puts usage($!.command)
+        exit 1
+      rescue VersionNeeded
+        puts "#{program_name} #{version}"
+        exit 0
+      rescue NoCommandGiven, UnknownOptions, UnknownCommand
+        $stderr.puts "ERROR: #{$!.message}"
+        $stderr.puts usage($!.respond_to?(:command) ? $!.command : nil)
+        exit 1
+      end
+    end
+
+    def parse(args)
+      non_options = @option_parser.parse(args)
+      command = non_options.shift
+      raise NoCommandGiven unless command
+      return command, non_options
+    end
+
+    def execute(command, non_options)
+      found = false
+      @commands.each do |command_name, options|
+        command_klass = options[:class]
+        aliases = [command_name]
+        aliases += command_klass.aliases if command_klass.respond_to?(:aliases)
+        return command_klass.new(non_options, @received_options).run if aliases.include?(command)
+      end
+
+      raise UnknownCommand.new(command, self)
+    end
+
+    def usage(command=nil)
+      message = []
+
+      if command then
+        command_klass = @commands[command][:class]
+        help =
+          if command_klass.respond_to?(:aliases) then
+            "#{command} (#{command_klass.aliases.join(", ")})"
+          else
+            "#{command}"
+          end
+        help = "#{help}: #{command_klass.help}" if command_klass.respond_to?(:help)
+        message << help
+        message << command_klass.detailed_help if command_klass.respond_to?(:detailed_help)
+        message << ""
+        message << "Valid options:"
+        @option_parser.summarize(message)
+      else
+        message << "usage: #{program_name.downcase} <SUBCOMMAND> [OPTIONS] [ARGS...]"
+        message << &quo