Update docs

Author: ethanhann

docs-src/commands.md

@@ -59,7 +59,7 @@ using InEngine.Core;
 
 namespace MyCommandPlugin
 {
-    public class MyOptions : AbstractPlugin
+    public class MyPlugin : AbstractPlugin
     {
         [VerbOption("my-command", HelpText="My example command.")]
         public MyCommand MyCommand { get; set; }
@@ -75,7 +75,7 @@ Add your plugin to the ["Plugins" list in appsettings.config](configuration) at
 Run your command:
 
 ```bash
-inengine.exe -pMyCommandPlugin my-command
+inengine.exe my-command
 ```
 
 ### Writing Output
@@ -154,78 +154,30 @@ Arbitrary commands can be run, with an argument list by leveraging the InEngine.
 The command lists directory contents using "ls" with the "-lhp" switches:
 
 ```bash
-inengine.exe -pInEngine.Core proc -c"/bin/ls" -a"-lhp"
+inengine.exe proc -c"/bin/ls" -a"-lhp"
 ```
 
-## View Available Plugins
+## View Commands
 
-Run inengine.exe without any arguments to see a list of plugins:
+Run inengine.exe with no arguments to see a list of commands:
 
-```text
-  ___       _____             _              _   _ _____ _____ 
- |_ _|_ __ | ____|_ __   __ _(_)_ __   ___  | \ | | ____|_   _|
-  | || '_ \|  _| | '_ \ / _` | | '_ \ / _ \ |  \| |  _|   | |  
-  | || | | | |___| | | | (_| | | | | |  __/_| |\  | |___  | |  
- |___|_| |_|_____|_| |_|\__, |_|_| |_|\___(_|_| \_|_____| |_|  
-                        |___/ 
-
-Usage:
-InEngine 3.x
-Copyright © 2017 Ethan Hann
-
-  p, plugin           Plug-In to activate.
-
-  s, scheduler        Run the scheduler.
-
-  c, configuration    (Default: ./appsettings.json) The path to the 
-                      configuration file.
-
-
-Plugins:
-  InEngine.Core
+```bash
+inengine.exe
 ```
 
-## View Commands in a Plugin
+![InEngine Command List](/images/inengine.png)
 
-Run inengine.exe with only the plugin specified:
 
-```bash
-inengine.exe -pInEngine.Core
-```
+!!! note "InEngine.Core is a Plugin"
+    The **InEngine.Core** library is itself a plugin that contains queueing, scheduling, and other commands. 
 
-The **InEngine.Core** library is itself a plugin that contains queue-related and other commands. 
-As an example, this is the help output for the core plugin.
-
-```text
-  ___       _____             _              _   _ _____ _____ 
- |_ _|_ __ | ____|_ __   __ _(_)_ __   ___  | \ | | ____|_   _|
-  | || '_ \|  _| | '_ \ / _` | | '_ \ / _ \ |  \| |  _|   | |  
-  | || | | | |___| | | | (_| | | | | |  __/_| |\  | |___  | |  
- |___|_| |_|_____|_| |_|\__, |_|_| |_|\___(_|_| \_|_____| |_|  
-                        |___/ 
-
-Plugin: 
-  Name:    InEngine.Core
-  Version: 3.x
-
-
-Commands:
-  queue:publish     Publish a command message to a queue.
-  queue:consume     Consume one or more command messages from the queue.
-  queue:length      Get the number of messages in the primary and secondary queues.
-  queue:flush       Clear the primary or secondary queues.
-  queue:republish   Republish failed messages to the queue.
-  queue:peek        Peek at messages in the primary or secondary queues.
-  echo              Echo some text to the console. Useful for end-to-end testing.
-  proc              Launch an arbitrary process.
-```
 
-## Print Help Text for a Plugin's Commands
+## View a Command's Help Text
 
 Run the command with the -h or --help arguments.
 
 ```bash
-inengine.exe -pInEngine.Core queue:publish -h
+inengine.exe queue:publish -h
 ```
 
 The **InEngine.Core** plugin's command to clear the InEngine.NET queues produces this help message. 

docs-src/index.md

@@ -10,12 +10,12 @@ Get started by pulling the binaries from the [latest release](https://github.com
 Then run a command the **echo** command from the core plugin:
 
 ```bash
-inengine.exe -pInEngine.Core echo --text"Hello, world"
+inengine.exe echo --text"Hello, world"
 ```
 Or if you're a Linux or Mac OS X fan (like me!), use the **inengine** shell script ([Mono](http://www.mono-project.com/download/) is required):
 
 ```bash
-inengine -pInEngine.Core echo --text"Hello, world"
+inengine echo --text"Hello, world"
 ```
 
 Instead of downloading binaries and runtimes, you can pull the latest Docker image:
@@ -27,7 +27,7 @@ docker pull ethanhann/inengine:latest
 Now run a command in a container:
 
 ```bash
-docker run --rm inengine -pInEngine.Core echo --text"Hello, world"
+docker run --rm inengine echo --text"Hello, world"
 ``` 
 
 ## How does queueing work?
@@ -39,15 +39,15 @@ Want to queue our example echo command to run in the background or possibly on a
 Use the core plugin's **queue:publish** command:
 
 ```bash
-inengine.exe -pInEngine.Core queue:publish --command-plugin=InEngine.Core --command-verb=echo --args "text=Hello, world"
+inengine.exe queue:publish --command-plugin=InEngine.Core --command-verb=echo --args "text=Hello, world"
 ``` 
 
 How do we consume that queued echo command?
 
 Use the core plugin's **queue:consume** command of course:
 
 ```bash
-inengine.exe -pInEngine.Core queue:consume
+inengine.exe queue:consume
 ``` 
 
 ## How do I run non-.NET commands?
@@ -63,5 +63,5 @@ print 'Hello, world!'
 Now execute it with the **proc** command:
 
 ```bash
-inengine -pInEngine.Core proc --command=/usr/bin/python --args=helloworld.py
+inengine proc --command=/usr/bin/python --args=helloworld.py
 ```

docs-src/queuing.md

@@ -158,19 +158,19 @@ Note that all queue commands reside in the **InEngine.Core** plugin.
 This is an example of how to publish a command from the CLI by specifying the command's plugin, class name, and arguments:
 
 ```bash
-inengine.exe -pInEngine.Core queue:publish --command-plugin=MyCommandPlugin --command-class=MyCommand --args "text=bar"
+inengine.exe queue:publish --command-plugin=MyCommandPlugin --command-class=MyCommand --args "text=bar"
 ```
 
 There is an "Echo" command in the *InEngine.Core* package. It is useful for end-to-end testing with the queue feature.
 
 ```bash
-inengine.exe -pInEngine.Core queue:publish --command-plugin=InEngine.Core --command-class=InEngine.Core.Commands.Echo --args "text=foo"
+inengine.exe queue:publish --command-plugin=InEngine.Core --command-class=InEngine.Core.Commands.Echo --args "text=foo"
 ```
 
 The command verb can also be specified instead of the full class name:
 
 ```bash
-inengine.exe -pInEngine.Core queue:publish --command-plugin=InEngine.Core --command-verb=echo--args "text=foo"
+inengine.exe queue:publish --command-plugin=InEngine.Core --command-verb=echo--args "text=foo"
 ```
 
 ## Consuming Commands
@@ -180,13 +180,13 @@ inengine.exe -pInEngine.Core queue:publish --command-plugin=InEngine.Core --comm
 Commands can be consumed from the command line with this simple command:
 
 ```bash
-inengine.exe -pInEngine.Core queue:consume
+inengine.exe queue:consume
 ```
 
 Use the **--secondary** argument to consume the secondary queue instead of the primary queue:
 
 ```bash
-inengine.exe -pInEngine.Core queue:consume --secondary
+inengine.exe queue:consume --secondary
 ```
 
 ### With the Scheduler
@@ -219,40 +219,40 @@ new Consume {
 The **queue:length** command shows a quick summary of pending, in-progress, and failed commands in the primary and secondary queues:
 
 ```bash
-inengine.exe -pInEngine.Core queue:length
+inengine.exe queue:length
 ```
 
 ### Peek at Queued Commands
 
 The **queue:peek** command allows for queued commands to be inspected:
 
 ```bash
-inengine.exe -pInEngine.Core queue:peek --pending --in-progress --failed
+inengine.exe queue:peek --pending --in-progress --failed
 ```  
 
 It is of course possible to peek in the secondary queues:
 
 ```bash
-inengine.exe -pInEngine.Core queue:peek --pending --secondary
+inengine.exe queue:peek --pending --secondary
 ```
 
 Queued commands can be viewed in JSON which maybe useful for debugging:
 
 ```bash
-inengine.exe -pInEngine.Core queue:peek --pending --json
+inengine.exe queue:peek --pending --json
 ```  
 
 By default, up to the first 10 messages will be retrieved, but the range is configurable:
 
 ```bash
-inengine.exe -pInEngine.Core queue:peek --pending --to=100
+inengine.exe queue:peek --pending --to=100
 ```
 
 A slice of the queue can be retrieved using the from argument.
 For example, this queue:peek call retrieves the 100-200 queued commands:
 
 ```bash
-inengine.exe -pInEngine.Core queue:peek --pending --from=100 --to=200
+inengine.exe queue:peek --pending --from=100 --to=200
 ```
 
 ## Re-queuing Failed Commands
@@ -261,20 +261,20 @@ Commands that throw an exception are put in a special "failed" queue.
 They can be republished with the **queue:republish** command:
 
 ```bash
-inengine.exe -pInEngine.Core queue:republish
+inengine.exe queue:republish
 ```
 
 Failed secondary queue commands can be republished as well:
 
 ```bash
-inengine.exe -pInEngine.Core queue:republish --secondary
+inengine.exe queue:republish --secondary
 ```
 
 By default, only 100 failed commands are republished at a time.
 The is configurable:
 
 ```bash
-inengine.exe -pInEngine.Core queue:republish --limit=1000
+inengine.exe queue:republish --limit=1000
 ```
 
 ## Primary and Secondary Queue
@@ -289,7 +289,7 @@ If it is desirable, different [configuration files](configuration) can be used t
 Simply create a new config file with a new QueueName setting and point inengine.exe at it with the -c argument:
 
 ```bash
-inengine.exe -cMyCustomSettingsFile.json -pInEngine.Core queue:consume
+inengine.exe -cMyCustomSettingsFile.json queue:consume
 ```
 
 ## Message Compression