aidp 0.10.0 → 0.12.0

data/lib/aidp/cli.rb

@@ -12,6 +12,8 @@ require_relative "cli/first_run_wizard"
 module Aidp
   # CLI interface for AIDP
   class CLI
+    include Aidp::MessageDisplay
+
     # Simple options holder for instance methods (used in specs)
     attr_accessor :options
 
@@ -20,21 +22,6 @@ module Aidp
       @prompt = prompt
     end
 
-    # Helper method for consistent message display using TTY::Prompt
-    def display_message(message, type: :info)
-      color = case type
-      when :error then :red
-      when :success then :green
-      when :warning then :yellow
-      when :info then :blue
-      when :highlight then :cyan
-      when :muted then :bright_black
-      else :white
-      end
-
-      @prompt.say(message, color: color)
-    end
-
     # Instance version of harness status (used by specs; non-interactive)
     def harness_status
       modes = %i[analyze execute]
@@ -68,9 +55,9 @@ module Aidp
       status = if options[:expect_error] == true
         "error"
       elsif step.nil?
-        "success"  # Initial call without step
+        "success" # Initial call without step
       else
-        "completed"  # Subsequent calls with specific step
+        "completed" # Subsequent calls with specific step
       end
 
       {
@@ -154,20 +141,7 @@ module Aidp
     end
 
     class << self
-      # Class-level display_message method for CLI output
-      def display_message(message, type: :info)
-        prompt = TTY::Prompt.new
-        color = case type
-        when :error then :red
-        when :success then :green
-        when :warning then :yellow
-        when :info then :blue
-        when :highlight then :cyan
-        when :muted then :bright_black
-        else :white
-        end
-        prompt.say(message, color: color)
-      end
+      extend Aidp::MessageDisplay::ClassMethods
 
       def run(args = ARGV)
         # Handle subcommands first (status, jobs, kb, harness)
@@ -209,7 +183,7 @@ module Aidp
 
         # Initialize the enhanced TUI
         tui = Aidp::Harness::UI::EnhancedTUI.new
-        workflow_selector = Aidp::Harness::UI::EnhancedWorkflowSelector.new(tui)
+        workflow_selector = Aidp::Harness::UI::EnhancedWorkflowSelector.new(tui, project_dir: Dir.pwd)
 
         # Start TUI display loop
         tui.start_display_loop
@@ -251,15 +225,67 @@ module Aidp
         options = {}
 
         parser = OptionParser.new do |opts|
-          opts.banner = "Usage: aidp [options]"
+          opts.banner = "Usage: aidp [COMMAND] [options]"
+          opts.separator ""
+          opts.separator "AI Development Pipeline - Autonomous development workflow automation"
           opts.separator ""
-          opts.separator "Start the interactive TUI (default)"
+          opts.separator "Commands:"
+          opts.separator "  analyze [--background]   Start analyze mode workflow"
+          opts.separator "  execute [--background]   Start execute mode workflow"
+          opts.separator "  status                   Show current system status"
+          opts.separator "  jobs                     Manage background jobs"
+          opts.separator "    list                     - List all jobs"
+          opts.separator "    status <id> [--follow]   - Show job status"
+          opts.separator "    logs <id> [--tail]       - Show job logs"
+          opts.separator "    stop <id>                - Stop a running job"
+          opts.separator "  checkpoint               View progress checkpoints and metrics"
+          opts.separator "    show                     - Show latest checkpoint"
+          opts.separator "    summary [--watch]        - Show progress summary with trends"
+          opts.separator "    history [N]              - Show last N checkpoints"
+          opts.separator "    metrics                  - Show detailed metrics"
+          opts.separator "    clear [--force]          - Clear checkpoint data"
+          opts.separator "  providers                Show provider health dashboard"
+          opts.separator "    info <name>              - Show detailed provider information"
+          opts.separator "    refresh [name]           - Refresh provider capabilities info"
+          opts.separator "  mcp                      MCP server dashboard and management"
+          opts.separator "    dashboard                - Show all MCP servers across providers"
+          opts.separator "    check <servers...>       - Check provider eligibility for servers"
+          opts.separator "  harness                  Manage harness state"
+          opts.separator "    status                   - Show harness status"
+          opts.separator "    reset                    - Reset harness state"
+          opts.separator "  kb                       Knowledge base commands"
+          opts.separator "    show <topic>             - Show knowledge base topic"
           opts.separator ""
           opts.separator "Options:"
 
           opts.on("-h", "--help", "Show this help message") { options[:help] = true }
           opts.on("-v", "--version", "Show version information") { options[:version] = true }
-          opts.on("--setup-config", "Setup or reconfigure config file with current values as defaults") { options[:setup_config] = true }
+          opts.on("--setup-config", "Setup or reconfigure config file") { options[:setup_config] = true }
+
+          opts.separator ""
+          opts.separator "Examples:"
+          opts.separator "  # Start background execution"
+          opts.separator "  aidp execute --background"
+          opts.separator "  aidp execute --background --follow    # Start and follow logs"
+          opts.separator ""
+          opts.separator "  # Monitor background jobs"
+          opts.separator "  aidp jobs list                        # List all jobs"
+          opts.separator "  aidp jobs status <job_id>             # Show job status"
+          opts.separator "  aidp jobs logs <job_id> --tail        # Tail job logs"
+          opts.separator ""
+          opts.separator "  # Watch progress in real-time"
+          opts.separator "  aidp checkpoint summary --watch       # Auto-refresh every 5s"
+          opts.separator "  aidp checkpoint summary --watch --interval 10"
+          opts.separator ""
+          opts.separator "  # Other commands"
+          opts.separator "  aidp providers                        # Check provider health"
+          opts.separator "  aidp providers info claude            # Show detailed provider info"
+          opts.separator "  aidp providers refresh                # Refresh all provider info"
+          opts.separator "  aidp mcp                              # Show MCP server dashboard"
+          opts.separator "  aidp mcp check dash-api filesystem    # Check provider eligibility"
+          opts.separator "  aidp checkpoint history 20            # Show last 20 checkpoints"
+          opts.separator ""
+          opts.separator "For more information, visit: https://github.com/viamin/aidp"
         end
 
         parser.parse!(args)
@@ -270,18 +296,21 @@ module Aidp
       # Determine if the invocation is a subcommand style call
       def subcommand?(args)
         return false if args.nil? || args.empty?
-        %w[status jobs kb harness execute analyze].include?(args.first)
+        %w[status jobs kb harness execute analyze providers checkpoint mcp].include?(args.first)
       end
 
       def run_subcommand(args)
         cmd = args.shift
         case cmd
         when "status" then run_status_command
-        when "jobs" then run_jobs_command
+        when "jobs" then run_jobs_command(args)
         when "kb" then run_kb_command(args)
         when "harness" then run_harness_command(args)
         when "execute" then run_execute_command(args)
         when "analyze" then run_execute_command(args, mode: :analyze) # symmetry
+        when "providers" then run_providers_command(args)
+        when "checkpoint" then run_checkpoint_command(args)
+        when "mcp" then run_mcp_command(args)
         else
           display_message("Unknown command: #{cmd}", type: :info)
           return 1
@@ -298,10 +327,11 @@ module Aidp
         display_message("Use 'aidp analyze' or 'aidp execute' to start a workflow", type: :info)
       end
 
-      def run_jobs_command
+      def run_jobs_command(args = [])
         require_relative "cli/jobs_command"
         jobs_cmd = Aidp::CLI::JobsCommand.new(prompt: TTY::Prompt.new)
-        jobs_cmd.run
+        subcommand = args.shift
+        jobs_cmd.run(subcommand, args)
       end
 
       def run_kb_command(args)
@@ -336,6 +366,8 @@ module Aidp
         approve_step = nil
         reset = false
         no_harness = false
+        background = false
+        follow = false
 
         until flags.empty?
           token = flags.shift
@@ -343,6 +375,8 @@ module Aidp
           when "--no-harness" then no_harness = true
           when "--reset" then reset = true
           when "--approve" then approve_step = flags.shift
+          when "--background" then background = true
+          when "--follow" then follow = true
           else
             step ||= token unless token.start_with?("--")
           end
@@ -361,6 +395,35 @@ module Aidp
           display_message("Use 'aidp #{mode}' without arguments", type: :info)
           return
         end
+
+        # Handle background execution
+        if background
+          require_relative "jobs/background_runner"
+          runner = Aidp::Jobs::BackgroundRunner.new(Dir.pwd)
+
+          display_message("Starting #{mode} mode in background...", type: :info)
+          job_id = runner.start(mode, {})
+
+          display_message("✓ Started background job: #{job_id}", type: :success)
+          display_message("", type: :info)
+          display_message("Monitor progress:", type: :info)
+          display_message("  aidp jobs status #{job_id}", type: :info)
+          display_message("  aidp jobs logs #{job_id} --tail", type: :info)
+          display_message("  aidp checkpoint summary", type: :info)
+          display_message("", type: :info)
+          display_message("Stop the job:", type: :info)
+          display_message("  aidp jobs stop #{job_id}", type: :info)
+
+          if follow
+            display_message("", type: :info)
+            display_message("Following logs (Ctrl+C to stop following)...", type: :info)
+            sleep 1 # Give daemon time to start writing logs
+            runner.follow_job_logs(job_id)
+          end
+
+          return
+        end
+
         if step
           display_message("Running #{mode} step '#{step}' with enhanced TUI harness", type: :highlight)
           display_message("progress indicators", type: :info)
@@ -386,6 +449,414 @@ module Aidp
         display_message("workflow selection options", type: :info)
       end
 
+      def run_checkpoint_command(args)
+        require_relative "execute/checkpoint"
+        require_relative "execute/checkpoint_display"
+
+        sub = args.shift || "summary"
+        checkpoint = Aidp::Execute::Checkpoint.new(Dir.pwd)
+        display = Aidp::Execute::CheckpointDisplay.new
+
+        case sub
+        when "show"
+          latest = checkpoint.latest_checkpoint
+          if latest
+            display.display_checkpoint(latest, show_details: true)
+          else
+            display_message("No checkpoint data found.", type: :info)
+          end
+
+        when "summary"
+          watch = args.include?("--watch")
+          interval = extract_interval_option(args) || 5
+
+          if watch
+            watch_checkpoint_summary(checkpoint, display, interval)
+          else
+            summary = checkpoint.progress_summary
+            if summary
+              display.display_progress_summary(summary)
+            else
+              display_message("No checkpoint data found.", type: :info)
+            end
+          end
+
+        when "history"
+          limit = args.shift || "10"
+          history = checkpoint.checkpoint_history(limit: limit.to_i)
+          if history.any?
+            display.display_checkpoint_history(history, limit: limit.to_i)
+          else
+            display_message("No checkpoint history found.", type: :info)
+          end
+
+        when "metrics"
+          latest = checkpoint.latest_checkpoint
+          unless latest
+            display_message("No checkpoint data found.", type: :info)
+            return
+          end
+
+          display_message("", type: :info)
+          display_message("📊 Detailed Metrics", type: :info)
+          display_message("=" * 60, type: :muted)
+
+          metrics = latest[:metrics]
+          display_message("Lines of Code: #{metrics[:lines_of_code]}", type: :info)
+          display_message("File Count: #{metrics[:file_count]}", type: :info)
+          display_message("Test Coverage: #{metrics[:test_coverage]}%", type: :info)
+          display_message("Code Quality: #{metrics[:code_quality]}%", type: :info)
+          display_message("PRD Task Progress: #{metrics[:prd_task_progress]}%", type: :info)
+
+          if metrics[:tests_passing]
+            status = metrics[:tests_passing] ? "✓ Passing" : "✗ Failing"
+            display_message("Tests: #{status}", type: :info)
+          end
+
+          if metrics[:linters_passing]
+            status = metrics[:linters_passing] ? "✓ Passing" : "✗ Failing"
+            display_message("Linters: #{status}", type: :info)
+          end
+
+          display_message("=" * 60, type: :muted)
+          display_message("", type: :info)
+
+        when "clear"
+          force = args.include?("--force")
+          unless force
+            prompt = TTY::Prompt.new
+            confirm = prompt.yes?("Are you sure you want to clear all checkpoint data?")
+            return unless confirm
+          end
+
+          checkpoint.clear
+          display_message("✓ Checkpoint data cleared.", type: :success)
+
+        else
+          display_message("Usage: aidp checkpoint <show|summary|history|metrics|clear>", type: :info)
+          display_message("  show              - Show the latest checkpoint data", type: :info)
+          display_message("  summary [--watch] - Show progress summary with trends", type: :info)
+          display_message("  history [N]       - Show last N checkpoints", type: :info)
+          display_message("  metrics           - Show detailed metrics", type: :info)
+          display_message("  clear [--force]   - Clear all checkpoint data", type: :info)
+        end
+      end
+
+      def watch_checkpoint_summary(checkpoint, display, interval)
+        display_message("Watching checkpoint summary (refresh: #{interval}s, Ctrl+C to exit)...", type: :info)
+        display_message("", type: :info)
+
+        begin
+          loop do
+            # Clear screen
+            print "\e[2J\e[H"
+
+            summary = checkpoint.progress_summary
+            if summary
+              display.display_progress_summary(summary)
+
+              # Show last update time
+              if summary[:current] && summary[:current][:timestamp]
+                last_update = Time.parse(summary[:current][:timestamp])
+                age = Time.now - last_update
+                display_message("", type: :info)
+                display_message("Last update: #{format_time_ago_simple(age)} | Refreshing in #{interval}s...", type: :muted)
+              end
+            else
+              display_message("No checkpoint data found. Waiting for data...", type: :info)
+            end
+
+            sleep interval
+          end
+        rescue Interrupt
+          display_message("\nStopped watching checkpoint summary", type: :info)
+        end
+      end
+
+      def extract_interval_option(args)
+        args.each_with_index do |arg, i|
+          if arg == "--interval" && args[i + 1]
+            return args[i + 1].to_i
+          elsif arg.start_with?("--interval=")
+            return arg.split("=")[1].to_i
+          end
+        end
+        nil
+      end
+
+      def format_time_ago_simple(seconds)
+        if seconds < 60
+          "#{seconds.to_i}s ago"
+        elsif seconds < 3600
+          "#{(seconds / 60).to_i}m ago"
+        else
+          "#{(seconds / 3600).to_i}h ago"
+        end
+      end
+
+      def run_providers_command(args)
+        subcommand = args.first if args.first && !args.first.start_with?("--")
+
+        case subcommand
+        when "info"
+          args.shift # Remove 'info'
+          run_providers_info_command(args)
+          return
+        when "refresh"
+          args.shift # Remove 'refresh'
+          run_providers_refresh_command(args)
+          return
+        end
+
+        # Accept flags directly on `aidp providers` now (health is implicit)
+        no_color = false
+        args.reject! do |a|
+          if a == "--no-color"
+            no_color = true
+            true
+          else
+            false
+          end
+        end
+        configuration = Aidp::Harness::Configuration.new(Dir.pwd)
+        pm = Aidp::Harness::ProviderManager.new(configuration, prompt: TTY::Prompt.new)
+
+        # Use TTY::Spinner for progress indication
+        require "tty-spinner"
+        start_time = Time.now
+        spinner = TTY::Spinner.new(":spinner Gathering provider health...", format: :dots)
+        spinner.auto_spin
+
+        begin
+          rows = pm.health_dashboard
+        ensure
+          spinner.stop
+          elapsed = (Time.now - start_time).round(2)
+          display_message("Provider Health Dashboard (#{elapsed}s)", type: :highlight)
+        end
+        require "tty-table"
+        color = ->(text, code) { "\e[#{code}m#{text}\e[0m" }
+        status_color = lambda do |status|
+          case status
+          when /healthy/ then 32
+          when /unhealthy_auth/ then 31
+          when /unhealthy/ then 33
+          when /circuit/ then 35
+          else 37
+          end
+        end
+        availability_color = ->(avail) { (avail == "yes") ? 32 : 31 }
+        rate_color = ->(rl) { rl.start_with?("yes") ? 33 : 36 }
+        circuit_color = lambda do |c|
+          c.start_with?("open") ? 31 : 32
+        end
+        table_rows = rows.map do |r|
+          last_used = r[:last_used] ? r[:last_used].strftime("%H:%M:%S") : "-"
+          cb = r[:circuit_breaker]
+          cb += " (#{r[:circuit_breaker_remaining]}s)" if r[:circuit_breaker_remaining]
+          rl = if r[:rate_limited]
+            r[:rate_limit_reset_in] ? "yes (#{r[:rate_limit_reset_in]}s)" : "yes"
+          else
+            "no"
+          end
+          tokens = (r[:total_tokens].to_i > 0) ? r[:total_tokens].to_s : "0"
+          reason = r[:unhealthy_reason] || "-"
+          if no_color || !$stdout.tty?
+            [r[:provider], r[:status], (r[:available] ? "yes" : "no"), cb, rl, tokens, last_used, reason]
+          else
+            [
+              color.call(r[:provider], "1;97"),
+              color.call(r[:status], status_color.call(r[:status])),
+              color.call(r[:available] ? "yes" : "no", availability_color.call(r[:available] ? "yes" : "no")),
+              color.call(cb, circuit_color.call(cb)),
+              color.call(rl, rate_color.call(rl)),
+              color.call(tokens, 37),
+              color.call(last_used, 90),
+              ((reason == "-") ? reason : color.call(reason, 33))
+            ]
+          end
+        end
+        header = ["Provider", "Status", "Avail", "Circuit", "RateLimited", "Tokens", "LastUsed", "Reason"]
+        table = TTY::Table.new header, table_rows
+        display_message(table.render(:basic), type: :info)
+      rescue => e
+        display_message("Failed to display provider health: #{e.message}", type: :error)
+      end
+
+      def run_providers_info_command(args)
+        require_relative "harness/provider_info"
+
+        provider_name = args.shift
+        unless provider_name
+          display_message("Usage: aidp providers info <provider_name>", type: :info)
+          display_message("Example: aidp providers info claude", type: :info)
+          return
+        end
+
+        force_refresh = args.include?("--refresh")
+
+        display_message("Provider Information: #{provider_name}", type: :highlight)
+        display_message("=" * 60, type: :muted)
+
+        provider_info = Aidp::Harness::ProviderInfo.new(provider_name, Dir.pwd)
+        info = provider_info.get_info(force_refresh: force_refresh)
+
+        if info.nil?
+          display_message("No information available for provider: #{provider_name}", type: :error)
+          return
+        end
+
+        # Display basic info
+        display_message("Last Checked: #{info[:last_checked]}", type: :info)
+        display_message("CLI Available: #{info[:cli_available] ? "Yes" : "No"}", type: info[:cli_available] ? :success : :error)
+
+        # Display authentication
+        if info[:auth_method]
+          display_message("\nAuthentication Method: #{info[:auth_method]}", type: :info)
+        end
+
+        # Display MCP support
+        display_message("\nMCP Support: #{info[:mcp_support] ? "Yes" : "No"}", type: info[:mcp_support] ? :success : :info)
+
+        # Display MCP servers if available
+        if info[:mcp_servers]&.any?
+          display_message("\nMCP Servers: (#{info[:mcp_servers].size} configured)", type: :highlight)
+          info[:mcp_servers].each do |server|
+            status_symbol = server[:enabled] ? "✓" : "○"
+            display_message("  #{status_symbol} #{server[:name]} (#{server[:status]})", type: server[:enabled] ? :success : :muted)
+            display_message("    #{server[:description]}", type: :muted) if server[:description]
+          end
+        elsif info[:mcp_support]
+          display_message("\nMCP Servers: None configured", type: :muted)
+        end
+
+        # Display permission modes
+        if info[:permission_modes]&.any?
+          display_message("\nPermission Modes:", type: :highlight)
+          info[:permission_modes].each do |mode|
+            display_message("  - #{mode}", type: :info)
+          end
+        end
+
+        # Display capabilities
+        if info[:capabilities]&.any?
+          display_message("\nCapabilities:", type: :highlight)
+          info[:capabilities].each do |cap, value|
+            next unless value
+
+            display_message("  ✓ #{cap.to_s.split("_").map(&:capitalize).join(" ")}", type: :success)
+          end
+        end
+
+        # Display notable flags
+        if info[:flags]&.any?
+          display_message("\nNotable Flags: (#{info[:flags].size} total)", type: :highlight)
+          # Show first 10 flags
+          info[:flags].take(10).each do |name, flag_info|
+            display_message("  #{flag_info[:flag]}", type: :info)
+            display_message("    #{flag_info[:description][0..80]}...", type: :muted) if flag_info[:description]
+          end
+
+          if info[:flags].size > 10
+            display_message("\n  ... and #{info[:flags].size - 10} more flags", type: :muted)
+            display_message("  Run '#{get_binary_name(provider_name)} --help' for full details", type: :muted)
+          end
+        end
+
+        display_message("\n" + "=" * 60, type: :muted)
+        display_message("Tip: Use --refresh to update this information", type: :muted)
+      end
+
+      def run_providers_refresh_command(args)
+        require_relative "harness/provider_info"
+        require "tty-spinner"
+
+        provider_name = args.shift
+        configuration = Aidp::Harness::Configuration.new(Dir.pwd)
+        providers_to_refresh = if provider_name
+          [provider_name]
+        else
+          configuration.configured_providers
+        end
+
+        display_message("Refreshing provider information...", type: :info)
+        display_message("", type: :info)
+
+        providers_to_refresh.each do |prov|
+          spinner = TTY::Spinner.new("[:spinner] #{prov}...", format: :dots)
+          spinner.auto_spin
+
+          provider_info = Aidp::Harness::ProviderInfo.new(prov, Dir.pwd)
+          info = provider_info.gather_info
+
+          if info[:cli_available]
+            spinner.success("(available)")
+          else
+            spinner.error("(unavailable)")
+          end
+        end
+
+        display_message("\n✓ Provider information refreshed", type: :success)
+        display_message("Use 'aidp providers info <name>' to view details", type: :muted)
+      end
+
+      def run_mcp_command(args)
+        require_relative "cli/mcp_dashboard"
+
+        subcommand = args.shift
+
+        dashboard = Aidp::CLI::McpDashboard.new(Dir.pwd)
+
+        case subcommand
+        when "dashboard", "list", nil
+          # Extract flags
+          no_color = args.include?("--no-color")
+          dashboard.display_dashboard(no_color: no_color)
+
+        when "check"
+          # Check eligibility for specific servers
+          required_servers = args
+          if required_servers.empty?
+            display_message("Usage: aidp mcp check <server1> [server2] ...", type: :info)
+            display_message("Example: aidp mcp check filesystem brave-search", type: :info)
+            return
+          end
+
+          dashboard.display_task_eligibility(required_servers)
+
+        else
+          display_message("Usage: aidp mcp <command>", type: :info)
+          display_message("", type: :info)
+          display_message("Commands:", type: :info)
+          display_message("  dashboard, list     Show MCP servers across all providers (default)", type: :info)
+          display_message("  check <servers...>  Check which providers have required MCP servers", type: :info)
+          display_message("", type: :info)
+          display_message("Examples:", type: :info)
+          display_message("  aidp mcp                              # Show dashboard", type: :info)
+          display_message("  aidp mcp dashboard --no-color         # Show without colors", type: :info)
+          display_message("  aidp mcp check filesystem dash-api    # Check provider eligibility", type: :info)
+        end
+      end
+
+      def get_binary_name(provider_name)
+        case provider_name
+        when "claude", "anthropic"
+          "claude"
+        when "cursor"
+          "cursor"
+        when "gemini"
+          "gemini"
+        when "codex"
+          "codex"
+        when "github_copilot"
+          "gh"
+        when "opencode"
+          "opencode"
+        else
+          provider_name
+        end
+      end
+
       def extract_mode_option(args)
         mode = nil
         args.each do |arg|
@@ -403,17 +874,20 @@ module Aidp
 
       def select_mode_interactive(tui)
         mode_options = [
+          "🤖 Guided Workflow (Copilot) - AI helps you choose the right workflow",
           "🔬 Analyze Mode - Analyze your codebase for insights and recommendations",
           "🏗️ Execute Mode - Build new features with guided development workflow"
         ]
         selected = tui.single_select("Welcome to AI Dev Pipeline! Choose your mode", mode_options, default: 1)
         # Announce mode explicitly in headless contexts (handled internally otherwise)
         if (defined?(RSpec) || ENV["RSPEC_RUNNING"]) && tui.respond_to?(:announce_mode)
-          tui.announce_mode(:analyze) if selected == mode_options[0]
-          tui.announce_mode(:execute) if selected == mode_options[1]
+          tui.announce_mode(:guided) if selected == mode_options[0]
+          tui.announce_mode(:analyze) if selected == mode_options[1]
+          tui.announce_mode(:execute) if selected == mode_options[2]
         end
-        return :analyze if selected == mode_options[0]
-        return :execute if selected == mode_options[1]
+        return :guided if selected == mode_options[0]
+        return :analyze if selected == mode_options[1]
+        return :execute if selected == mode_options[2]
         :analyze
       end