llm.rb 15.0.3 → 15.2.0

data/docs/deepdive/fundamentals/tools.md

@@ -32,8 +32,8 @@ Tools that spawn subprocesses can include
 [`LLM::Tool::Utils`](https://r.uby.dev/api-docs/llm.rb/LLM/Tool/Utils.html)
 to get shared
 [`wait(command:, timeout:)`](https://r.uby.dev/api-docs/llm.rb/LLM/Tool/Utils.html#wait-instance_method)
-and `now` help. The built-in `Shell`, `Git`, `Rg`, and `Mkdir` tools
-use it to kill a command that exceeds its `timeout`.
+and `now` help. The built-in `Exec`, `Git`, `Rg`, `Mkdir`, and `Ruby`
+tools use it to kill a command that exceeds its `timeout`.
 
 If
 [`LLM::Tool#call`](https://r.uby.dev/api-docs/llm.rb/LLM/Tool.html#call)
@@ -44,22 +44,34 @@ also handle errors yourself inside
 by rescuing and returning a domain-specific error hash.
 
 ```ruby
-class Shell < LLM::Tool
-  set name: "shell",
-      description: "execute a shell command",
-      parameters: [
-        [:name, String, "the command's name", {required: true}],
-        [:arguments, Array[String], "command args", {default: []}]
-      ]
+require "llm/tools/utils"
+
+class Exec < LLM::Tool
+  include Utils
+
+  name "exec"
+  description "run a command without a shell"
+  parameter :name, String, "the command's name"
+  parameter :arguments, Array[String], "command args"
+  required %i[name]
+  defaults arguments: [], timeout: 60, max_bytes: :max_bytes
 
-  def call(name:, arguments: [])
-    out = `#{name.shellescape} #{arguments.map(&:shellescape).join(" ")}`
-    {ok: $?.success?, out:}
+  def self.max_bytes(bytes = nil)
+    bytes ? (@max_bytes = bytes) : (@max_bytes || 75_000)
+  end
+
+  def call(name:, arguments: [], timeout: 60, max_bytes: self.class.max_bytes)
+    command = spawn(name:, arguments:, max_bytes:)
+    wait(command:, timeout:)
+    {ok: command.success?, stdout: command.stdout, stderr: command.stderr}
+  rescue LLM::Interrupt
+    command.kill! if command&.running?
+    raise
   end
 end
 
 llm = LLM.deepseek(key: ENV["KEY"])
-agent = LLM::Agent.new(llm, tools: [Shell], stream: $stdout)
+agent = LLM::Agent.new(llm, tools: [Exec], stream: $stdout)
 agent.talk "What files are in the current working directory?"
 ```
 
@@ -165,17 +177,26 @@ message: "boom"}` to the model. You can also rescue inside
 and return your own error shape that gives the model more context.
 
 ```ruby
-class Shell < LLM::Tool
-  set name: "shell",
-      description: "run a shell command",
-      parameters: [
-        [:name, String, "the command name", {required: true}],
-        [:arguments, Array[String], "command args", {default: []}]
-      ]
+require "llm/tools/utils"
 
-  def call(name:, arguments: [])
-    out = `#{name} #{arguments.join(" ")}`
-    {ok: $?.success?, out:}
+class Exec < LLM::Tool
+  include Utils
+
+  name "exec"
+  description "run a command without a shell"
+  parameter :name, String, "the command name"
+  parameter :arguments, Array[String], "command args"
+  required %i[name]
+  defaults arguments: [], timeout: 60, max_bytes: :max_bytes
+
+  def self.max_bytes(bytes = nil)
+    bytes ? (@max_bytes = bytes) : (@max_bytes || 75_000)
+  end
+
+  def call(name:, arguments: [], timeout: 60, max_bytes: self.class.max_bytes)
+    command = spawn(name:, arguments:, max_bytes:)
+    wait(command:, timeout:)
+    {ok: command.success?, stdout: command.stdout, stderr: command.stderr}
   rescue Errno::ENOENT
     {ok: false, error: "command not found: #{name}"}
   end
@@ -215,17 +236,28 @@ with a Hash. The keys match the individual method names. The
 individual `parameter` method does.
 
 ```ruby
-class Shell < LLM::Tool
-  set name: "shell",
-      description: "execute a shell command",
+require "llm/tools/utils"
+
+class Exec < LLM::Tool
+  include Utils
+
+  set name: "exec",
+      description: "run a command without a shell",
       parameters: [
         [:name, String, "the command's name", {required: true}],
-        [:arguments, Array[String], "One or more arguments", {default: []}]
+        [:arguments, Array[String], "command args", {default: []}],
+        [:timeout, Integer, "timeout in seconds", {default: 60}],
+        [:max_bytes, Integer, "max bytes to emit", {default: 75_000}]
       ]
 
-  def call(name:, arguments: [])
-    out = `#{name.shellescape} #{arguments.map(&:shellescape).join(" ")}`
-    {ok: $?.success?, out:}
+  def self.max_bytes(bytes = nil)
+    bytes ? (@max_bytes = bytes) : (@max_bytes || 75_000)
+  end
+
+  def call(name:, arguments: [], timeout: 60, max_bytes: self.class.max_bytes)
+    command = spawn(name:, arguments:, max_bytes:)
+    wait(command:, timeout:)
+    {ok: command.success?, stdout: command.stdout, stderr: command.stderr}
   end
 end
 ```
@@ -298,7 +330,7 @@ decide to retry or continue with the results it has.
 
 #### Overview
 
-llm.rb ships with twelve ready-made tools that cover filesystem,
+llm.rb ships with thirteen ready-made tools that cover filesystem,
 search, and shell operations. Load them all with
 `require "llm/tools"`. Each tool is documented in the
 [built-in tools catalog](builtin_tools.md).

data/docs/deepdive/reference/cost.md

@@ -18,7 +18,7 @@ When you want to know what a conversation cost so far, call
 [`LLM::Context#cost`](https://r.uby.dev/api-docs/llm.rb/LLM/Context.html#cost-instance_method)
 (or
 [`LLM::Agent#cost`](https://r.uby.dev/api-docs/llm.rb/LLM/Agent.html#cost-instance_method))
-and read the breakdown. The REPL shows this live in its status bar
+and read the breakdown. The console shows this live in its status bar
 after every turn:
 
 ```ruby
@@ -102,7 +102,7 @@ returns the total in a compact, human-friendly format, rounded to
 two decimals (`"0.01"`). Components that were not used are `0`, so
 you never need to guard against `nil` when aggregating.
 
-The REPL renders context usage as a proportion, not a cost.
+The console renders context usage as a proportion, not a cost.
 [`LLM::Context#context_usage`](https://r.uby.dev/api-docs/llm.rb/LLM/Context.html#context_usage-instance_method)
 returns a `Rational` of the tokens used over the context window
 (for example `Rational(100, 10_000)`), or `nil` when the window is

data/docs/deepdive/reference/model_registry.md

@@ -7,7 +7,7 @@
 The model registry is a catalog of every model each provider offers,
 shipped with llm.rb under `data/<provider>.json`. The data is sourced
 from [models.dev](https://models.dev) and powers cost estimation,
-context-window limits, and the `/model` auto-complete in the REPL.
+context-window limits, and the `/model` auto-complete in the console.
 
 [`LLM::Registry`](https://r.uby.dev/api-docs/llm.rb/LLM/Registry.html)
 exposes that catalog, and
@@ -210,7 +210,7 @@ require "llm"
 reg = LLM::Registry.for(:openai)
 list = reg.models.sort
 list.first.id # => "text-embedding-3-small"
-list.last.id  # => "chatgpt-image-latest"
+list.last.id  # => "gpt-image-1-mini" (unpriced sorts last)
 ```
 
 #### Why would I use it?

data/docs/deepdive/reference/tracer.md

@@ -28,7 +28,7 @@ provider or an agent:
 
 ```ruby
 llm = LLM.deepseek(key: ENV["KEY"])
-llm.tracer = LLM::Tracer::PrettyLogger.new(llm)
+llm.tracer = LLM::Tracer.pretty_logger(llm)
 agent = LLM::Agent.new(llm)
 agent.talk "Hello"
 ```
@@ -59,12 +59,14 @@ request a provider makes. Three built-in tracers are available:
 [`LLM::Tracer::Telemetry`](https://r.uby.dev/api-docs/llm.rb/LLM/Tracer/Telemetry.html)
 (OpenTelemetry).
 
-For a shorter way to build a
-[`LLM::Tracer::Logger`](https://r.uby.dev/api-docs/llm.rb/LLM/Tracer/Logger.html),
-use the [`LLM.logger`](https://r.uby.dev/api-docs/llm.rb/LLM.html#logger-class_method)
-convenience method. It takes a provider and forwards the options as
-a positional hash, so `LLM.logger(llm, io: $stdout)` is equivalent
-to `LLM::Tracer::Logger.new(llm, io: $stdout)`.
+For a shorter way to build the built-in tracers, use the
+[`LLM::Tracer.logger`](https://r.uby.dev/api-docs/llm.rb/LLM/Tracer.html#logger-class_method),
+[`LLM::Tracer.pretty_logger`](https://r.uby.dev/api-docs/llm.rb/LLM/Tracer.html#pretty_logger-class_method),
+and
+[`LLM::Tracer.telemetry`](https://r.uby.dev/api-docs/llm.rb/LLM/Tracer.html#telemetry-class_method)
+convenience methods. Each takes a provider and forwards its options to
+the matching tracer, so `LLM::Tracer.pretty_logger(llm, io: $stdout)`
+forwards `io:` to the pretty logger.
 
 ### Provider
 
@@ -86,7 +88,7 @@ consistent observability without configuring each agent individually.
 
 ```ruby
 llm = LLM.deepseek(key: ENV["KEY"])
-llm.tracer = LLM::Tracer::Logger.new(llm, io: $stdout)
+llm.tracer = LLM::Tracer.logger(llm, io: $stdout)
 ```
 
 #### Why would I use it?
@@ -118,7 +120,7 @@ same provider unaffected.
 
 ```ruby
 llm = LLM.deepseek(key: ENV["KEY"])
-agent = LLM::Agent.new(llm, tracer: LLM::Tracer::Logger.new(llm, io: $stdout))
+agent = LLM::Agent.new(llm, tracer: LLM::Tracer.logger(llm, io: $stdout))
 ```
 
 #### Why would I use it?
@@ -153,21 +155,21 @@ accepts an `io:` option to redirect output.
 
 ```ruby
 llm = LLM.deepseek(key: ENV["KEY"])
-llm.tracer = LLM::Tracer::PrettyLogger.new(llm)
+llm.tracer = LLM::Tracer.pretty_logger(llm)
 ```
 
 ##### Agent-local
 
 ```ruby
 llm = LLM.deepseek(key: ENV["KEY"])
-agent = LLM::Agent.new(llm, tracer: LLM::Tracer::PrettyLogger.new(llm))
+agent = LLM::Agent.new(llm, tracer: LLM::Tracer.pretty_logger(llm))
 ```
 
 ##### Custom output
 
 ```ruby
-tracer = LLM::Tracer::PrettyLogger.new(llm, io: $stdout)
-tracer = LLM::Tracer::PrettyLogger.new(llm, io: File.open("trace.log", "a"))
+tracer = LLM::Tracer.pretty_logger(llm, io: $stdout)
+tracer = LLM::Tracer.pretty_logger(llm, path: "trace.log")
 ```
 
 #### Why would I use it?

data/docs/deepdive.md

@@ -37,7 +37,7 @@ code, `#### Why would I use it?` explains the use case, and
 #### Why would I use it?
 
 The deepdive documents everything there is to know about llm.rb.
-It includes the fundamnetals, advanced patterns, configuration
+It includes the fundamentals, advanced patterns, configuration
 options, ORM support, protocol support, and edge cases. It is
 useful when you need to go beyond the basics.
 
@@ -69,7 +69,7 @@ is the best place to start if you are new to llm.rb.
 - [Concurrency](deepdive/features/concurrency.md)
 - [Embeddings](deepdive/features/embeddings.md)
 - [Database](deepdive/features/database.md)
-- [REPL](deepdive/features/repl.md)
+- [Console](deepdive/features/console.md)
 
 ## Advanced
 

data/lib/llm/active_record/acts_as_agent.rb

@@ -20,7 +20,10 @@ module LLM::ActiveRecord
       ##
       # @return [Class<LLM::Agent>]
       def agent
-        @agent ||= Class.new(LLM::Agent)
+        return @agent if defined?(@agent)
+        @agent = Class.new(LLM::Agent)
+        @agent.name(self)
+        @agent
       end
 
       ##
@@ -112,11 +115,12 @@ module LLM::ActiveRecord
       #  This method does not persist to the database,
       #  but it can inspect and alter runtime state in
       #  a way that is temporary.
-      # @param (see LLM::Agent#repl)
-      # @return (see LLM::Agent#repl)
-      def repl(**params)
-        ctx.repl(**params)
+      # @param (see LLM::Agent#console)
+      # @return (see LLM::Agent#console)
+      def console(**params)
+        ctx.console(**params)
       end
+      alias_method :repl, :console
 
       private
 

data/lib/llm/agent.rb

@@ -128,7 +128,7 @@ module LLM
     # Set or get an agent's name
     # @note
     #  This method serves as a self-documenting string
-    #  and it is used by {LLM::Repl LLM::Repl}. It is
+    #  and it is used by {LLM::Console LLM::Console}. It is
     #  optional but recommended.
     # @param [String] name
     #  The agent name
@@ -143,7 +143,12 @@ module LLM
           @name
         end
       else
-        @name = block || name
+        if Class === name
+          name  = name.to_s.split("::").last
+          @name = name.gsub(CASE_PATTERN, "-").downcase
+        else
+          @name = block || name
+        end
       end
     end
 
@@ -292,7 +297,7 @@ module LLM
     #
     # @example
     #   class Agent < LLM::Agent
-    #     tracer { LLM::Tracer::Logger.new(llm, io: $stdout) }
+    #     tracer { LLM::Tracer.logger(llm, io: $stdout) }
     #   end
     #
     # @param [LLM::Tracer, Proc, nil] tracer
@@ -372,7 +377,7 @@ module LLM
     # @return [Integer, nil]
     def self.retry_budget(budget = UNDEFINED)
       if budget.equal?(UNDEFINED)
-        @retry_budget.nil? ? 5 : @retry_budget
+        @retry_budget.nil? ? UNDEFINED : @retry_budget
       else
         @retry_budget = budget
       end
@@ -404,7 +409,11 @@ module LLM
       @llm = llm
       fields, fields_ivar = FIELDS, IVARS
       fields.each do |field|
-        resolvable = params.key?(field) ? params.delete(field) : (self.class.respond_to?(field) ? self.class.public_send(field) : nil)
+        resolvable = if params.key?(field)
+          params.delete(field)
+        else
+          (self.class.respond_to?(field) ? self.class.public_send(field) : nil)
+        end
         resolve_symbol = !%i[concurrency].include?(field)
         resolved = resolvable != nil ? resolve_option(self, resolvable, resolve_symbol:) : resolvable
         resolved = [*resolved].map(&:to_s) if field == :confirm && resolved
@@ -416,6 +425,13 @@ module LLM
           instance_variable_set(:"@#{field}", resolved)
         end
       end
+      ##
+      # Alibaba (token plan) will frequently issue rate
+      # limits or time outs that it recovers from. The
+      # higher retry count is to account for scenarios
+      # where it takes longer than expected to recover.
+      retry_budget = llm.name == :alibaba ? 8 : 5
+      params[:retry_budget] = retry_budget if params[:retry_budget].equal?(UNDEFINED)
       @ctx = LLM::Context.new(llm, {guard: LLM::Guard::Loop}.merge(params))
       @path and File.readable?(@path) ? @ctx.restore(path:) : nil
     end
@@ -486,6 +502,12 @@ module LLM
       @ctx.messages
     end
 
+    ##
+    # @return [Integer]
+    def retry_budget
+      @ctx.retry_budget
+    end
+
     ##
     # @return [Array<LLM::Function>]
     def pending_functions
@@ -644,14 +666,16 @@ module LLM
     end
 
     ##
-    # Start a minimalist repl that can interact
+    # Start an agent console that can interact
     # with the agent and its current state. This
-    # method requires the 'curses' gem to be installed
-    # and available to require.
+    # method requires the following gems to be
+    # installed and available to require:
+    # 'unicode-display_width', 'kramdown', 'curses',
+    # 'test-cmd.rb', and 'xchan.rb'.
     #
     # @note
     #  By default this method disables the tracer for
-    #  the duration of the repl session, and restores
+    #  the duration of the console session, and restores
     #  it afterwards.
     # @param [String] name
     #  The agent's name.
@@ -660,14 +684,14 @@ module LLM
     #  The path to a file where runtime state is read
     #  from, and written to
     # @param [Array<LLM::Tool>] tools
-    #  Extra tools to attach for the repl session
+    #  Extra tools to attach for the console session
     # @param [Array<String>] skills
-    #  Extra skills to attach for the repl session
+    #  Extra skills to attach for the console session
     # @param [Boolean] tracer
     #  When true, the tracer is kept alive during the
-    #  repl session. Default is false.
+    #  console session. Default is false.
     # @return [void]
-    def repl(name: self.name, path: nil, tools: [], skills: [], tracer: false, trace: nil)
+    def console(name: self.name, path: nil, tools: [], skills: [], tracer: false, trace: nil)
       if trace != nil
         warn "llm.rb: trace option is deprecated, use tracer instead"
         tracer = trace
@@ -676,13 +700,14 @@ module LLM
         previous    = self.tracer
         self.tracer = nil
       end
-      require_relative "repl" unless defined?(::LLM::Repl)
-      LLM::Repl.new(agent: self, name:, path:, tools:, skills:).start
+      require_relative "console" unless defined?(::LLM::Console)
+      LLM::Console.new(agent: self, name:, path:, tools:, skills:).start
     ensure
       if !tracer
         self.tracer = previous
       end
     end
+    alias_method :repl, :console
 
     ##
     # @see LLM::Context#params

data/lib/llm/{repl → console}/bar.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-class LLM::Repl
+class LLM::Console
   ##
-  # The {LLM::Repl::Bar LLM::Repl::Bar} class renders a
+  # The {LLM::Console::Bar LLM::Console::Bar} class renders a
   # small progress bar for the REPL. It is used to show
   # the remaining size of the model's context window in
   # a compact form near the input line.
@@ -21,7 +21,7 @@ class LLM::Repl
     #  The fraction of the context window used, or nil when unknown
     #  (eg after compaction).
     # @param [Integer] width
-    # @return [LLM::Repl::Bar]
+    # @return [LLM::Console::Bar]
     def initialize(fraction:, width: 10)
       @width = width
       @label, @filled = remainder(fraction)

data/lib/llm/{repl → console}/buffer.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class LLM::Repl
+class LLM::Console
   ##
   # This class maintains conversation state that includes
   # the conversation itself, and metadata associated with
@@ -16,9 +16,9 @@ class LLM::Repl
   # row by overwriting its contents repeatedly.
   class Buffer
     ##
-    # @param [LLM::Repl] repl
-    #  An instance of {LLM::Repl LLM::Repl}.
-    # @return [LLM::Repl::Buffer]
+    # @param [LLM::Console] console
+    #  An instance of {LLM::Console LLM::Console}.
+    # @return [LLM::Console::Buffer]
     def initialize(repl)
       @repl   = repl
       @window = repl.window
@@ -147,15 +147,15 @@ class LLM::Repl
         if token == "\n"
           rows << []
         elsif token.match?(/\s/)
-          if sum(rows.last) + token.length <= width
+          if sum(rows.last) + Node.width(token) <= width
             rows.last << Node.new(token, attrs)
           end
-        elsif sum(rows.last) + token.length > width
+        elsif sum(rows.last) + Node.width(token) > width
           if sum(rows.last) == 0
             ##
             # A single word wider than the row: break it
-            # every width characters.
-            token.scan(/.{1,#{width}}/).each do |piece|
+            # every width columns.
+            slices(token, width).each do |piece|
               rows.last << Node.new(piece, attrs)
               if sum(rows.last) >= width
                 rows << []
@@ -190,7 +190,22 @@ class LLM::Repl
     ##
     # @api private
     def sum(row)
-      row.sum { _1[:text].to_s.length }
+      row.sum { _1.size }
+    end
+
+    ##
+    # Splits a single word into pieces that each fit within the
+    # buffer's width, measured in display columns.
+    # @api private
+    def slices(token, width)
+      pieces = []
+      remaining = token
+      until remaining.empty?
+        piece = Node.slice(remaining, width)
+        pieces << piece
+        remaining = remaining[piece.length..] || +""
+      end
+      pieces
     end
   end
 end

data/lib/llm/{repl → console}/color.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-class LLM::Repl
+class LLM::Console
   ##
-  # The {LLM::Repl::Color LLM::Repl::Color} module returns
+  # The {LLM::Console::Color LLM::Console::Color} module returns
   # bitmasks that are understood as colors by the Curses
   # library. They can be bitwise OR'ed with other attributes,
   # such as Curses::A_BOLD.

data/lib/llm/{repl → console}/command.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-class LLM::Repl
+class LLM::Console
   ##
-  # The {LLM::Repl::Command LLM::Repl::Command} class is the superclass
+  # The {LLM::Console::Command LLM::Console::Command} class is the superclass
   # of all read-eval-print loop commands. A command has a name, and a
   # description. This basic version does not implement parameters. A
   # command is accessible via the `/` prefix: eg `/exit`.
@@ -57,9 +57,9 @@ class LLM::Repl
     ##
     # Find a command by a name, or by an input string.
     # @example find by name
-    #  LLM::Repl::Command.find_by(name: "exit")
+    #  LLM::Console::Command.find_by(name: "exit")
     # @example find by input string
-    #  LLM::Repl::Command.find_by(input: "/exit")
+    #  LLM::Console::Command.find_by(input: "/exit")
     # @note
     #  The input string must be prefixed with "/"
     #  or it won't be matched. The match is made
@@ -68,7 +68,7 @@ class LLM::Repl
     #  but "/exitnow" will not.
     # @param [String] input
     # @param [String] name
-    # @return [LLM::Repl::Command, nil]
+    # @return [LLM::Console::Command, nil]
     def self.find_by(input: UNDEFINED, name: UNDEFINED)
       if input != UNDEFINED
         return nil unless input[0] == "/"
@@ -82,7 +82,7 @@ class LLM::Repl
     end
 
     ##
-    # @param [LLM::Repl::Command] outer
+    # @param [LLM::Console::Command] outer
     #  A new subclass
     # @return [void]
     def self.inherited(outer)
@@ -99,7 +99,7 @@ class LLM::Repl
     end
 
     ##
-    # @return [Array<LLM::Repl::Command]
+    # @return [Array<LLM::Console::Command]
     def self.registry
       @registry.transform_keys(&:name)
     end
@@ -160,7 +160,7 @@ class LLM::Repl
     end
 
     ##
-    # @return [LLM::Repl]
+    # @return [LLM::Console]
     attr_reader :repl
 
     ##
@@ -168,8 +168,8 @@ class LLM::Repl
     attr_reader :agent
 
     ##
-    # @param [LLM::Repl] repl
-    # @return [LLM::Repl::Command]
+    # @param [LLM::Console] console
+    # @return [LLM::Console::Command]
     def initialize(repl)
       @repl = repl
       @agent = repl.agent
@@ -235,7 +235,7 @@ class LLM::Repl
       self.class.parameters
     end
 
-    require_relative "commands/compact"
+    require_relative "commands/keep"
     require_relative "commands/exit"
     require_relative "commands/help"
     require_relative "commands/model"
@@ -244,4 +244,4 @@ end
 
 ##
 # Convenience constant
-LLM::Command = LLM::Repl::Command
+LLM::Command = LLM::Console::Command

data/lib/llm/{repl → console}/commands/exit.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
-class LLM::Repl
+class LLM::Console
   ##
-  # The 'exit' command exits the read-eval-print loop
-  # by throwing. The {LLM::Repl LLM::Repl} class covers
+  # The 'exit' command exits the interactive console
+  # by throwing. The {LLM::Console LLM::Console} class covers
   # the loop with a catch that gracefully recovers and
   # exits the loop.
   class Command::Exit < Command
     name "exit"
-    description "exits the repl"
+    description "exits the console"
 
     ##
     # @return [void]

data/lib/llm/{repl → console}/commands/help.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class LLM::Repl
+class LLM::Console
   class Help < Command
     name "help"
     description "show help for a given command"