Have Pub make use of the arg parser.

lib/args/args.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 /**
  * This library lets you define parsers for parsing raw command-line arguments
  * into a set of options and values using [GNU][] and [POSIX][] style options.
  *
  * ## Defining options ##
  *
@@ skipping 183 matching lines @@
     : _options = <_Option>{},
       _optionNames = <String>[];
 
   /**
    * Defines a flag. Throws an [IllegalArgumentException] if:
    *
    * * There is already an option named [name].
    * * There is already an option using abbreviation [abbr].
    */
   void addFlag(String name, [String abbr, String help, bool defaultsTo = false,
-      void callback(bool value)]) {
+      bool negatable = true, void callback(bool value)]) {
     _addOption(name, abbr, help, null, null, defaultsTo, callback,
-        isFlag: true);
+        isFlag: true, negatable: negatable);
   }
 
   /**
    * Defines a value-taking option. Throws an [IllegalArgumentException] if:
    *
    * * There is already an option with name [name].
    * * There is already an option using abbreviation [abbr].
    */
   void addOption(String name, [String abbr, String help, List<String> allowed,
       Map<String, String> allowedHelp, String defaultsTo,
       void callback(bool value)]) {
-    _addOption(name, abbr, help, allowed, allowedHelp, defaultsTo, callback,
-        isFlag: false);
+    _addOption(name, abbr, help, allowed, allowedHelp, defaultsTo,
+        callback, isFlag: false);
   }
 
   void _addOption(String name, String abbr, String help, List<String> allowed,
       Map<String, String> allowedHelp, defaultsTo,
-      void callback(bool value), [bool isFlag]) {
+      void callback(bool value), [bool isFlag, bool negatable = false]) {
     // Make sure the name isn't in use.
     if (_options.containsKey(name)) {
       throw new IllegalArgumentException('Duplicate option "$name".');
     }
 
     // Make sure the abbreviation isn't too long or in use.
     if (abbr != null) {
       if (abbr.length > 1) {
         throw new IllegalArgumentException(
             'Abbreviation "$abbr" is longer than one character.');
       }
 
       var existing = _findByAbbr(abbr);
       if (existing != null) {
         throw new IllegalArgumentException(
             'Abbreviation "$abbr" is already used by "${existing.name}".');
       }
     }
 
     _options[name] = new _Option(name, abbr, help, allowed, allowedHelp,
-        defaultsTo, callback, isFlag: isFlag);
+        defaultsTo, callback, isFlag: isFlag, negatable: negatable);
     _optionNames.add(name);
   }
 
   /**
    * Parses [args], a list of command-line arguments, matches them against the
    * flags and options defined by this parser, and returns the result.
    */
   ArgResults parse(List<String> args) {
     _args = args;
     _current = 0;
@@ skipping 171 matching lines @@
         _setOption(results, option, longOpt[3]);
       } else {
         // Option like --foo, so look for the value as the next arg.
         _readNextArgAsValue(results, option);
       }
     } else if (name.startsWith('no-')) {
       // See if it's a negated flag.
       name = name.substring('no-'.length);
       option = _options[name];
       _validate(option != null, 'Could not find an option named "$name".');
-      _validate(option.isFlag, 'Cannot negate non-flag option "$name.');
+      _validate(option.isFlag, 'Cannot negate non-flag option "$name".');
+      _validate(option.negatable, 'Cannot negate option "$name".');
 
       _setOption(results, option, false);
     } else {
       _validate(option != null, 'Could not find an option named "$name".');
     }
 
     return true;
   }
 
   /**
@@ skipping 48 matching lines @@
 
 class _Option {
   final String name;
   final String abbreviation;
   final List allowed;
   final defaultValue;
   final Function callback;
   final String help;
   final Map<String, String> allowedHelp;
   final bool isFlag;
+  final bool negatable;
 
   _Option(this.name, this.abbreviation, this.help, this.allowed,
-      this.allowedHelp, this.defaultValue, this.callback, [this.isFlag]);
+      this.allowedHelp, this.defaultValue, this.callback, [this.isFlag,
+      this.negatable]);
 }
 
 /**
  * Takes an [ArgParser] and generates a string of usage (i.e. help) text for its
  * defined options. Internally, it works like a tabular printer. The output is
  * divided into three horizontal columns, like so:
  *
  *     -h, --help  Prints the usage information
  *     |  |        |                                 |
  *
@@ skipping 85 matching lines @@
 
   String getAbbreviation(_Option option) {
     if (option.abbreviation != null) {
       return '-${option.abbreviation}, ';
     } else {
       return '';
     }
   }
 
   String getLongOption(_Option option) {
-    if (option.isFlag) {
+    if (option.negatable) {
       return '--[no-]${option.name}';
     } else {
       return '--${option.name}';
     }
   }
 
   String getAllowedTitle(String allowed) {
     return '      [$allowed]';
   }
 
@@ skipping 95 matching lines @@
       allowedBuffer.add(allowed);
       if (allowed == option.defaultValue) {
         allowedBuffer.add(' (default)');
       }
       first = false;
     }
     allowedBuffer.add(']');
     return allowedBuffer.toString();
   }
 }