aidp 0.13.0 → 0.14.0

data/lib/aidp/cli/issue_importer.rb

@@ -0,0 +1,359 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "uri"
+require "open3"
+
+module Aidp
+  # Handles importing GitHub issues into AIDP work loops
+  class IssueImporter
+    include Aidp::MessageDisplay
+
+    # Initialize the importer
+    #
+    # @param gh_available [Boolean, nil] (test-only) forcibly sets whether gh CLI is considered
+    #   available. When nil (default) we auto-detect. This enables deterministic specs without
+    #   depending on developer environment.
+    def initialize(gh_available: nil, enable_bootstrap: true)
+      @gh_available = gh_available.nil? ? gh_cli_available? : gh_available
+      @enable_bootstrap = enable_bootstrap
+    end
+
+    def import_issue(identifier)
+      issue_url = normalize_issue_identifier(identifier)
+      return nil unless issue_url
+
+      issue_data = fetch_issue_data(issue_url)
+      return nil unless issue_data
+
+      display_imported_issue(issue_data)
+      create_work_loop_prompt(issue_data)
+      perform_bootstrap(issue_data)
+
+      issue_data
+    end
+
+    private
+
+    def normalize_issue_identifier(identifier)
+      case identifier
+      when /^https:\/\/github\.com\/([^\/]+)\/([^\/]+)\/issues\/(\d+)/
+        # Full URL: https://github.com/owner/repo/issues/123
+        identifier
+      when /^(\d+)$/
+        # Just issue number - need to detect current repo
+        current_repo = detect_current_github_repo
+        if current_repo
+          "https://github.com/#{current_repo}/issues/#{identifier}"
+        else
+          display_message("❌ Issue number provided but not in a GitHub repository", type: :error)
+          nil
+        end
+      when /^([^\/]+)\/([^\/]+)#(\d+)$/
+        # owner/repo#123 format
+        owner, repo, number = $1, $2, $3
+        "https://github.com/#{owner}/#{repo}/issues/#{number}"
+      else
+        display_message("❌ Invalid issue identifier. Use: URL, number, or owner/repo#number", type: :error)
+        nil
+      end
+    end
+
+    def detect_current_github_repo
+      return nil unless File.exist?(".git")
+
+      # Try to get origin URL
+      stdout, _stderr, status = Open3.capture3("git remote get-url origin")
+      return nil unless status.success?
+
+      origin_url = stdout.strip
+
+      # Parse GitHub URL (both SSH and HTTPS)
+      if origin_url =~ %r{github\.com[:/]([^/]+)/([^/\s]+?)(?:\.git)?$}
+        "#{$1}/#{$2}"
+      end
+    end
+
+    def fetch_issue_data(issue_url)
+      # Extract owner, repo, and issue number from URL
+      match = issue_url.match(/github\.com\/([^\/]+)\/([^\/]+)\/issues\/(\d+)/)
+      return nil unless match
+
+      owner, repo, number = match[1], match[2], match[3]
+
+      # First try GitHub CLI if available (works for private repos)
+      if @gh_available
+        display_message("🔍 Fetching issue via GitHub CLI...", type: :info)
+        issue_data = fetch_via_gh_cli(owner, repo, number)
+        return issue_data if issue_data
+      end
+
+      # Fallback to public API
+      display_message("🔍 Fetching issue via GitHub API...", type: :info)
+      fetch_via_api(owner, repo, number)
+    end
+
+    def fetch_via_gh_cli(owner, repo, number)
+      cmd = [
+        "gh", "issue", "view", number,
+        "--repo", "#{owner}/#{repo}",
+        "--json", "title,body,labels,milestone,comments,state,assignees,number,url"
+      ]
+
+      stdout, stderr, status = Open3.capture3(*cmd)
+
+      unless status.success?
+        display_message("⚠️ GitHub CLI failed: #{stderr.strip}", type: :warn)
+        return nil
+      end
+
+      begin
+        data = JSON.parse(stdout)
+        normalize_gh_cli_data(data)
+      rescue JSON::ParserError => e
+        display_message("❌ Failed to parse GitHub CLI response: #{e.message}", type: :error)
+        nil
+      end
+    end
+
+    def fetch_via_api(owner, repo, number)
+      uri = URI("https://api.github.com/repos/#{owner}/#{repo}/issues/#{number}")
+
+      begin
+        response = Net::HTTP.get_response(uri)
+
+        unless response.code == "200"
+          case response.code
+          when "404"
+            display_message("❌ Issue not found (may be private)", type: :error)
+          when "403"
+            display_message("❌ API rate limit exceeded", type: :error)
+          else
+            display_message("❌ GitHub API error: #{response.code}", type: :error)
+          end
+          return nil
+        end
+
+        data = JSON.parse(response.body)
+        normalize_api_data(data)
+      rescue => e
+        display_message("❌ Failed to fetch issue: #{e.message}", type: :error)
+        nil
+      end
+    end
+
+    def normalize_gh_cli_data(data)
+      {
+        number: data["number"],
+        title: data["title"],
+        body: data["body"] || "",
+        state: data["state"],
+        url: data["url"],
+        labels: data["labels"]&.map { |l| l["name"] } || [],
+        milestone: data["milestone"]&.dig("title"),
+        assignees: data["assignees"]&.map { |a| a["login"] } || [],
+        comments: data["comments"]&.length || 0,
+        source: "gh_cli"
+      }
+    end
+
+    def normalize_api_data(data)
+      {
+        number: data["number"],
+        title: data["title"],
+        body: data["body"] || "",
+        state: data["state"],
+        url: data["html_url"],
+        labels: data["labels"]&.map { |l| l["name"] } || [],
+        milestone: data["milestone"]&.dig("title"),
+        assignees: data["assignees"]&.map { |a| a["login"] } || [],
+        comments: data["comments"] || 0,
+        source: "api"
+      }
+    end
+
+    def display_imported_issue(issue_data)
+      display_message("✅ Successfully imported GitHub issue", type: :success)
+      display_message("", type: :info)
+      display_message("📋 Issue ##{issue_data[:number]}: #{issue_data[:title]}", type: :highlight)
+      display_message("🔗 URL: #{issue_data[:url]}", type: :muted)
+      display_message("📊 State: #{issue_data[:state]}", type: :info)
+
+      unless issue_data[:labels].empty?
+        display_message("🏷️ Labels: #{issue_data[:labels].join(", ")}", type: :info)
+      end
+
+      if issue_data[:milestone]
+        display_message("🎯 Milestone: #{issue_data[:milestone]}", type: :info)
+      end
+
+      unless issue_data[:assignees].empty?
+        display_message("👤 Assignees: #{issue_data[:assignees].join(", ")}", type: :info)
+      end
+
+      if issue_data[:comments] > 0
+        display_message("💬 Comments: #{issue_data[:comments]}", type: :info)
+      end
+
+      display_message("", type: :info)
+      display_message("📝 Description:", type: :info)
+      # Truncate body if too long
+      body = issue_data[:body]
+      if body.length > 500
+        display_message("#{body[0..497]}...", type: :muted)
+        display_message("[Truncated - full description available in work loop]", type: :muted)
+      else
+        display_message(body, type: :muted)
+      end
+    end
+
+    def create_work_loop_prompt(issue_data)
+      # Create PROMPT.md for work loop
+      prompt_content = generate_prompt_content(issue_data)
+
+      File.write("PROMPT.md", prompt_content)
+      display_message("", type: :info)
+      display_message("📄 Created PROMPT.md for work loop", type: :success)
+      display_message("   You can now run 'aidp execute' to start working on this issue", type: :info)
+    end
+
+    def generate_prompt_content(issue_data)
+      <<~PROMPT
+        # Work Loop: GitHub Issue ##{issue_data[:number]}
+
+        ## Instructions
+        You are working on a GitHub issue imported into AIDP. Your responsibilities:
+        1. Read this PROMPT.md file to understand what needs to be done
+        2. Complete the work described in the issue below
+        3. **IMPORTANT**: Edit this PROMPT.md file yourself to:
+           - Remove completed items
+           - Update with current status
+           - Keep it concise (remove unnecessary context)
+           - Mark the issue COMPLETE when 100% done
+        4. After you finish, tests and linters will run automatically
+        5. If tests/linters fail, you'll see the errors in the next iteration
+
+        ## Completion Criteria
+        Mark this issue COMPLETE by adding this line to PROMPT.md:
+        ```
+        STATUS: COMPLETE
+        ```
+
+        ## GitHub Issue Details
+
+        **Issue ##{issue_data[:number]}**: #{issue_data[:title]}
+        **URL**: #{issue_data[:url]}
+        **State**: #{issue_data[:state]}
+        #{"**Labels**: #{issue_data[:labels].join(", ")}" unless issue_data[:labels].empty?}
+        #{"**Milestone**: #{issue_data[:milestone]}" if issue_data[:milestone]}
+        #{"**Assignees**: #{issue_data[:assignees].join(", ")}" unless issue_data[:assignees].empty?}
+
+        ## Issue Description
+
+        #{issue_data[:body]}
+
+        ## Implementation Plan
+
+        Based on the issue description above, implement the requested changes:
+
+        1. [ ] Analyze the requirements from the issue description
+        2. [ ] Plan the implementation approach
+        3. [ ] Implement the requested functionality
+        4. [ ] Add or update tests as needed
+        5. [ ] Update documentation if required
+        6. [ ] Verify all tests pass
+        7. [ ] Mark STATUS: COMPLETE
+
+        ## Notes
+
+        - This issue was imported via AIDP issue import (source: #{issue_data[:source]})
+        - Original issue URL: #{issue_data[:url]}
+        - If you need clarification, refer back to the original issue
+        - Consider any linked PRs or related issues mentioned in the description
+      PROMPT
+    end
+
+    def gh_cli_available?
+      _stdout, _stderr, status = Open3.capture3("gh", "--version")
+      status.success?
+    rescue Errno::ENOENT
+      false
+    end
+
+    def perform_bootstrap(issue_data)
+      return if ENV["AIDP_DISABLE_BOOTSTRAP"] == "1"
+      return unless @enable_bootstrap
+      return unless git_repo?
+
+      ensure_initial_commit
+
+      branch = branch_name(issue_data)
+      create_branch(branch)
+      create_checkpoint_tag(issue_data)
+      detect_and_record_tooling
+    rescue => e
+      display_message("⚠️ Bootstrap step failed: #{e.message}", type: :warn)
+    end
+
+    def git_repo?
+      File.exist?(".git")
+    end
+
+    # Ensure we have an initial commit so that branch and tag creation succeed in fresh repos.
+    # In an empty repo without commits, git checkout -b and git tag will fail due to missing HEAD.
+    def ensure_initial_commit
+      _stdout, _stderr, status = Open3.capture3("git", "rev-parse", "--verify", "HEAD")
+      return if status.success? # already have at least one commit
+
+      # Create a placeholder file if nothing is present so commit has content
+      placeholder = ".aidp_bootstrap"
+      unless File.exist?(placeholder)
+        File.write(placeholder, "Initial commit placeholder for AIDP bootstrap\n")
+      end
+
+      Open3.capture3("git", "add", "-A")
+      _c_stdout, c_stderr, c_status = Open3.capture3("git", "commit", "-m", "chore(aidp): initial commit before bootstrap")
+      unless c_status.success?
+        display_message("⚠️ Could not create initial commit: #{c_stderr.strip}", type: :warn)
+      end
+    end
+
+    def branch_name(issue_data)
+      slug = issue_data[:title].downcase.gsub(/[^a-z0-9]+/, "-").gsub(/^-|-$/, "")[0, 40]
+      "aidp/iss-#{issue_data[:number]}-#{slug}"
+    end
+
+    def create_branch(name)
+      _stdout, stderr, status = Open3.capture3("git", "checkout", "-b", name)
+      if status.success?
+        display_message("🌿 Created branch #{name}", type: :success)
+      else
+        display_message("⚠️ Could not create branch: #{stderr.strip}", type: :warn)
+      end
+    end
+
+    def create_checkpoint_tag(issue_data)
+      tag = "aidp-start/#{issue_data[:number]}"
+      _stdout, stderr, status = Open3.capture3("git", "tag", tag)
+      if status.success?
+        display_message("🏷️  Added checkpoint tag #{tag}", type: :success)
+      else
+        display_message("⚠️ Could not create tag: #{stderr.strip}", type: :warn)
+      end
+    end
+
+    def detect_and_record_tooling
+      require_relative "../tooling_detector"
+      result = Aidp::ToolingDetector.detect
+      return if result.test_commands.empty? && result.lint_commands.empty?
+
+      tooling_info = "# Detected Tooling\n\n" \
+        + (result.test_commands.empty? ? "" : "Test Commands:\n#{result.test_commands.map { |c| "- #{c}" }.join("\n")}\n\n") \
+        + (result.lint_commands.empty? ? "" : "Lint Commands:\n#{result.lint_commands.map { |c| "- #{c}" }.join("\n")}\n")
+
+      File.open("PROMPT.md", "a") { |f| f.puts("\n---\n\n#{tooling_info}") }
+      display_message("🧪 Detected tooling and appended to PROMPT.md", type: :info)
+    end
+  end
+end

data/lib/aidp/cli.rb

@@ -195,16 +195,20 @@ module Aidp
           # Get workflow configuration (no spinner - may wait for user input)
           workflow_config = workflow_selector.select_workflow(harness_mode: false, mode: mode)
 
+          # For guided mode, use the mode determined by the guided workflow selector
+          # Otherwise use the initially selected mode
+          actual_mode = workflow_config[:mode] || mode
+
           # Pass workflow configuration to harness
           harness_options = {
-            mode: mode,
+            mode: actual_mode,
             workflow_type: workflow_config[:workflow_type],
             selected_steps: workflow_config[:steps],
             user_input: workflow_config[:user_input]
           }
 
           # Create and run the enhanced harness
-          harness_runner = Aidp::Harness::EnhancedRunner.new(Dir.pwd, mode, harness_options)
+          harness_runner = Aidp::Harness::EnhancedRunner.new(Dir.pwd, actual_mode, harness_options)
           result = harness_runner.run
           display_harness_result(result)
           0
@@ -232,6 +236,8 @@ module Aidp
           opts.separator "Commands:"
           opts.separator "  analyze [--background]   Start analyze mode workflow"
           opts.separator "  execute [--background]   Start execute mode workflow"
+          opts.separator "  init                     Analyse project and bootstrap quality docs"
+          opts.separator "  watch <issues_url>       Run fully automatic watch mode"
           opts.separator "  status                   Show current system status"
           opts.separator "  jobs                     Manage background jobs"
           opts.separator "    list                     - List all jobs"
@@ -251,6 +257,7 @@ module Aidp
           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 "  config                   Manage configuration"
           opts.separator "    status                   - Show harness status"
           opts.separator "    reset                    - Reset harness state"
           opts.separator "  kb                       Knowledge base commands"
@@ -277,6 +284,14 @@ module Aidp
           opts.separator "  aidp checkpoint summary --watch       # Auto-refresh every 5s"
           opts.separator "  aidp checkpoint summary --watch --interval 10"
           opts.separator ""
+          opts.separator "  # Project bootstrap"
+          opts.separator "  aidp init"
+          opts.separator "  aidp config --interactive"
+          opts.separator "  # Fully automatic orchestration"
+          opts.separator ""
+          opts.separator "  aidp watch https://github.com/<org>/<repo>/issues"
+          opts.separator "  aidp watch owner/repo --interval 120 --provider claude"
+          opts.separator ""
           opts.separator "  # Other commands"
           opts.separator "  aidp providers                        # Check provider health"
           opts.separator "  aidp providers info claude            # Show detailed provider info"
@@ -296,7 +311,7 @@ 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 providers checkpoint mcp].include?(args.first)
+        %w[status jobs kb harness execute analyze providers checkpoint mcp issue config init watch].include?(args.first)
       end
 
       def run_subcommand(args)
@@ -311,6 +326,10 @@ module Aidp
         when "providers" then run_providers_command(args)
         when "checkpoint" then run_checkpoint_command(args)
         when "mcp" then run_mcp_command(args)
+        when "issue" then run_issue_command(args)
+        when "config" then run_config_command(args)
+        when "init" then run_init_command
+        when "watch" then run_watch_command(args)
         else
           display_message("Unknown command: #{cmd}", type: :info)
           return 1
@@ -907,6 +926,135 @@ module Aidp
           display_message("   Message: #{result[:message]}", type: :info) if result[:message]
         end
       end
+
+      def run_issue_command(args)
+        require_relative "cli/issue_importer"
+
+        usage = <<~USAGE
+          Usage: aidp issue <command> [options]
+
+          Commands:
+            import <identifier>    Import a GitHub issue
+                                  Identifier can be:
+                                  - Full URL: https://github.com/owner/repo/issues/123
+                                  - Issue number: 123 (when in a git repo)
+                                  - Shorthand: owner/repo#123
+
+          Examples:
+            aidp issue import https://github.com/rails/rails/issues/12345
+            aidp issue import 123
+            aidp issue import rails/rails#12345
+
+          Options:
+            -h, --help            Show this help message
+        USAGE
+
+        if args.empty? || args.include?("-h") || args.include?("--help")
+          display_message(usage, type: :info)
+          return
+        end
+
+        command = args.shift
+        case command
+        when "import"
+          identifier = args.shift
+          unless identifier
+            display_message("❌ Missing issue identifier", type: :error)
+            display_message(usage, type: :info)
+            return
+          end
+
+          importer = IssueImporter.new
+          issue_data = importer.import_issue(identifier)
+
+          if issue_data
+            display_message("", type: :info)
+            display_message("🚀 Ready to start work loop!", type: :success)
+            display_message("   Run: aidp execute", type: :info)
+          end
+        else
+          display_message("❌ Unknown issue command: #{command}", type: :error)
+          display_message(usage, type: :info)
+        end
+      end
+
+      def run_config_command(args)
+        interactive = false
+        dry_run = false
+
+        until args.empty?
+          token = args.shift
+          case token
+          when "--interactive"
+            interactive = true
+          when "--dry-run"
+            dry_run = true
+          when "-h", "--help"
+            display_config_usage
+            return
+          else
+            display_message("Unknown option: #{token}", type: :error)
+            display_config_usage
+            return
+          end
+        end
+
+        unless interactive
+          display_config_usage
+          return
+        end
+
+        wizard = Aidp::Setup::Wizard.new(Dir.pwd, prompt: TTY::Prompt.new, dry_run: dry_run)
+        wizard.run
+      end
+
+      def run_init_command
+        runner = Aidp::Init::Runner.new(Dir.pwd, prompt: TTY::Prompt.new)
+        runner.run
+      end
+
+      def run_watch_command(args)
+        if args.empty?
+          display_message("Usage: aidp watch <issues_url> [--interval SECONDS] [--provider NAME] [--once]", type: :info)
+          return
+        end
+
+        issues_url = args.shift
+        interval = Aidp::Watch::Runner::DEFAULT_INTERVAL
+        provider_name = nil
+        once = false
+
+        until args.empty?
+          token = args.shift
+          case token
+          when "--interval"
+            interval_value = args.shift
+            interval = interval_value.to_i if interval_value
+          when "--provider"
+            provider_name = args.shift
+          when "--once"
+            once = true
+          else
+            display_message("⚠️  Unknown watch option: #{token}", type: :warn)
+          end
+        end
+
+        runner = Aidp::Watch::Runner.new(
+          issues_url: issues_url,
+          interval: interval.positive? ? interval : Aidp::Watch::Runner::DEFAULT_INTERVAL,
+          provider_name: provider_name,
+          project_dir: Dir.pwd,
+          once: once,
+          prompt: TTY::Prompt.new
+        )
+        runner.start
+      rescue ArgumentError => e
+        display_message("❌ #{e.message}", type: :error)
+      end
+
+      def display_config_usage
+        display_message("Usage: aidp config --interactive [--dry-run]", type: :info)
+      end
     end # class << self
   end
 end