aidp 0.13.0 → 0.14.0

data/lib/aidp/tooling_detector.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Aidp
+  # Detect basic project tooling to seed work loop test & lint commands.
+  # Lightweight heuristic pass – prefers safety over guessing incorrectly.
+  class ToolingDetector
+    DETECTORS = [
+      :ruby_bundle,
+      :rspec,
+      :ruby_standardrb,
+      :node_jest,
+      :node_mocha,
+      :node_eslint,
+      :python_pytest
+    ].freeze
+
+    Result = Struct.new(:test_commands, :lint_commands, keyword_init: true)
+
+    def self.detect(root = Dir.pwd)
+      new(root).detect
+    end
+
+    def initialize(root = Dir.pwd)
+      @root = root
+    end
+
+    def detect
+      tests = []
+      linters = []
+
+      if ruby_project?
+        tests << bundle_prefix("rspec") if rspec?
+        linters << bundle_prefix("standardrb") if standard_rb?
+      end
+
+      if node_project?
+        tests << npm_or_yarn("test") if package_script?("test")
+        %w[lint eslint].each do |script|
+          if package_script?(script)
+            linters << npm_or_yarn(script)
+            break
+          end
+        end
+      end
+
+      if python_pytest?
+        tests << "pytest -q"
+      end
+
+      Result.new(
+        test_commands: tests.uniq,
+        lint_commands: linters.uniq
+      )
+    end
+
+    private
+
+    def bundle_prefix(cmd)
+      File.exist?(File.join(@root, "Gemfile")) ? "bundle exec #{cmd}" : cmd
+    end
+
+    def ruby_project?
+      File.exist?(File.join(@root, "Gemfile"))
+    end
+
+    def rspec?
+      File.exist?(File.join(@root, "spec")) &&
+        begin
+          File.readlines(File.join(@root, "Gemfile")).grep(/rspec/).any?
+        rescue
+          false
+        end
+    end
+
+    def standard_rb?
+      File.exist?(File.join(@root, "Gemfile")) &&
+        begin
+          File.readlines(File.join(@root, "Gemfile")).grep(/standard/).any?
+        rescue
+          false
+        end
+    end
+
+    def package_json
+      @package_json ||= begin
+        path = File.join(@root, "package.json")
+        return nil unless File.exist?(path)
+        JSON.parse(File.read(path))
+      rescue JSON::ParserError
+        nil
+      end
+    end
+
+    def node_project?
+      !!package_json
+    end
+
+    def package_script?(name)
+      package_json&.dig("scripts", name)
+    end
+
+    def npm_or_yarn(script)
+      if File.exist?(File.join(@root, "yarn.lock"))
+        "yarn #{script}"
+      else
+        "npm run #{script}"
+      end
+    end
+
+    def python_pytest?
+      Dir.glob(File.join(@root, "**", "pytest.ini")).any? ||
+        Dir.glob(File.join(@root, "**", "conftest.py")).any?
+    end
+  end
+end

data/lib/aidp/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Aidp
-  VERSION = "0.13.0"
+  VERSION = "0.14.0"
 end

data/lib/aidp/watch/build_processor.rb

@@ -0,0 +1,282 @@
+# frozen_string_literal: true
+
+require "open3"
+require "time"
+
+require_relative "../message_display"
+require_relative "../execute/prompt_manager"
+require_relative "../harness/runner"
+
+module Aidp
+  module Watch
+    # Handles the aidp-build trigger by running the autonomous work loop, creating
+    # a branch/PR, and posting completion status back to GitHub.
+    class BuildProcessor
+      include Aidp::MessageDisplay
+
+      BUILD_LABEL = "aidp-build"
+      IMPLEMENTATION_STEP = "16_IMPLEMENTATION"
+
+      def initialize(repository_client:, state_store:, project_dir: Dir.pwd)
+        @repository_client = repository_client
+        @state_store = state_store
+        @project_dir = project_dir
+      end
+
+      def process(issue)
+        number = issue[:number]
+        display_message("🛠️  Starting implementation for issue ##{number}", type: :info)
+
+        plan_data = ensure_plan_data(number)
+        return unless plan_data
+
+        branch_name = branch_name_for(issue)
+        @state_store.record_build_status(number, status: "running", details: {branch: branch_name, started_at: Time.now.utc.iso8601})
+
+        ensure_git_repo!
+        base_branch = detect_base_branch
+
+        checkout_branch(base_branch, branch_name)
+        prompt_content = build_prompt(issue: issue, plan_data: plan_data)
+        write_prompt(prompt_content)
+
+        user_input = build_user_input(issue: issue, plan_data: plan_data)
+        result = run_harness(user_input: user_input)
+
+        if result[:status] == "completed"
+          handle_success(issue: issue, branch_name: branch_name, base_branch: base_branch, plan_data: plan_data)
+        else
+          handle_failure(issue: issue, result: result)
+        end
+      rescue => e
+        display_message("❌ Implementation failed: #{e.message}", type: :error)
+        @state_store.record_build_status(issue[:number], status: "failed", details: {error: e.message})
+        raise
+      end
+
+      private
+
+      def ensure_plan_data(number)
+        data = @state_store.plan_data(number)
+        unless data
+          display_message("⚠️  No recorded plan for issue ##{number}. Skipping build trigger.", type: :warn)
+        end
+        data
+      end
+
+      def ensure_git_repo!
+        Dir.chdir(@project_dir) do
+          stdout, stderr, status = Open3.capture3("git", "rev-parse", "--is-inside-work-tree")
+          raise "Not a git repository: #{stderr.strip}" unless status.success? && stdout.strip == "true"
+        end
+      end
+
+      def detect_base_branch
+        Dir.chdir(@project_dir) do
+          stdout, _stderr, status = Open3.capture3("git", "symbolic-ref", "refs/remotes/origin/HEAD")
+          if status.success?
+            ref = stdout.strip
+            return ref.split("/").last if ref.include?("/")
+          end
+
+          %w[main master trunk].find do |candidate|
+            _out, _err, branch_status = Open3.capture3("git", "rev-parse", "--verify", candidate)
+            branch_status.success?
+          end || "main"
+        end
+      end
+
+      def checkout_branch(base_branch, branch_name)
+        Dir.chdir(@project_dir) do
+          run_git(%w[fetch origin], allow_failure: true)
+          run_git(["checkout", base_branch])
+          run_git(%w[pull --ff-only], allow_failure: true)
+          run_git(["checkout", "-B", branch_name])
+        end
+        display_message("🌿 Checked out #{branch_name}", type: :info)
+      end
+
+      def branch_name_for(issue)
+        slug = issue[:title].to_s.downcase.gsub(/[^a-z0-9]+/, "-").gsub(/^-|-$/, "")
+        "aidp/issue-#{issue[:number]}-#{slug[0, 32]}"
+      end
+
+      def build_prompt(issue:, plan_data:)
+        lines = []
+        lines << "# Implementation Contract for Issue ##{issue[:number]}"
+        lines << ""
+        lines << "## Summary"
+        lines << plan_value(plan_data, "summary").to_s.strip
+        lines << ""
+        lines << "## Tasks"
+        Array(plan_value(plan_data, "tasks")).each do |task|
+          lines << "- [ ] #{task}"
+        end
+        lines << "" unless Array(plan_value(plan_data, "tasks")).empty?
+        lines << "## Clarifying Answers / Notes"
+        lines << clarifications_from_comments(issue[:comments], plan_data)
+        lines << ""
+        lines << "## Original Issue Body"
+        lines << issue[:body].to_s
+        lines.join("\n")
+      end
+
+      def clarifications_from_comments(comments, plan_data)
+        return "_No additional context provided._" if comments.nil? || comments.empty?
+
+        comment_hint = plan_value(plan_data, "comment_hint")
+        relevant = comments.reject do |comment|
+          body = comment["body"].to_s
+          comment_hint && body.start_with?(comment_hint)
+        end
+
+        return "_No follow-up responses yet._" if relevant.empty?
+
+        relevant.map do |comment|
+          author = comment["author"] || "unknown"
+          created = comment["createdAt"] ? Time.parse(comment["createdAt"]).utc.iso8601 : "unknown"
+          "### #{author} (#{created})\n#{comment["body"]}"
+        end.join("\n\n")
+      rescue
+        "_Unable to parse comment thread._"
+      end
+
+      def write_prompt(content)
+        prompt_manager = Aidp::Execute::PromptManager.new(@project_dir)
+        prompt_manager.write(content)
+        display_message("📝 Wrote PROMPT.md with implementation contract", type: :info)
+      end
+
+      def build_user_input(issue:, plan_data:)
+        tasks = Array(plan_value(plan_data, "tasks"))
+        {
+          "Implementation Contract" => plan_value(plan_data, "summary").to_s,
+          "Tasks" => tasks.map { |task| "- #{task}" }.join("\n"),
+          "Issue URL" => issue[:url]
+        }.delete_if { |_k, v| v.nil? || v.empty? }
+      end
+
+      def run_harness(user_input:)
+        options = {
+          selected_steps: [IMPLEMENTATION_STEP],
+          workflow_type: :watch_mode,
+          user_input: user_input
+        }
+        runner = Aidp::Harness::Runner.new(@project_dir, :execute, options)
+        runner.run
+      end
+
+      def handle_success(issue:, branch_name:, base_branch:, plan_data:)
+        stage_and_commit(issue)
+        pr_url = create_pull_request(issue: issue, branch_name: branch_name, base_branch: base_branch)
+
+        comment = <<~COMMENT
+          ✅ Implementation complete for ##{issue[:number]}.
+          - Branch: `#{branch_name}`
+          - Pull Request: #{pr_url}
+
+          Summary:
+          #{plan_value(plan_data, "summary")}
+        COMMENT
+
+        @repository_client.post_comment(issue[:number], comment)
+        @state_store.record_build_status(
+          issue[:number],
+          status: "completed",
+          details: {branch: branch_name, pr_url: pr_url}
+        )
+        display_message("🎉 Posted completion comment for issue ##{issue[:number]}", type: :success)
+      end
+
+      def handle_failure(issue:, result:)
+        message = result[:message] || "Unknown failure"
+        comment = <<~COMMENT
+          ❌ Implementation attempt for ##{issue[:number]} failed.
+
+          Status: #{result[:status]}
+          Details: #{message}
+
+          Please review the repository for partial changes. The branch has been left intact for debugging.
+        COMMENT
+        @repository_client.post_comment(issue[:number], comment)
+        @state_store.record_build_status(
+          issue[:number],
+          status: "failed",
+          details: {message: message}
+        )
+        display_message("⚠️  Build failure recorded for issue ##{issue[:number]}", type: :warn)
+      end
+
+      def stage_and_commit(issue)
+        Dir.chdir(@project_dir) do
+          status_output = run_git(%w[status --porcelain])
+          if status_output.strip.empty?
+            display_message("ℹ️  No file changes detected after work loop.", type: :muted)
+            return
+          end
+
+          run_git(%w[add -A])
+          commit_message = "feat: implement ##{issue[:number]} #{issue[:title]}"
+          run_git(["commit", "-m", commit_message])
+          display_message("💾 Created commit: #{commit_message}", type: :info)
+        end
+      end
+
+      def create_pull_request(issue:, branch_name:, base_branch:)
+        title = "aidp: Resolve ##{issue[:number]} - #{issue[:title]}"
+        test_summary = gather_test_summary
+        body = <<~BODY
+          ## Summary
+          - Automated resolution for ##{issue[:number]}
+
+          ## Testing
+          #{test_summary}
+        BODY
+
+        output = @repository_client.create_pull_request(
+          title: title,
+          body: body,
+          head: branch_name,
+          base: base_branch,
+          issue_number: issue[:number]
+        )
+
+        extract_pr_url(output)
+      end
+
+      def gather_test_summary
+        Dir.chdir(@project_dir) do
+          log_path = File.join(".aidp", "logs", "test_runner.log")
+          return "- Fix-forward harness executed; refer to #{log_path}" unless File.exist?(log_path)
+
+          recent = File.readlines(log_path).last(20).map(&:strip).reject(&:empty?)
+          if recent.empty?
+            "- Fix-forward harness executed successfully."
+          else
+            "- Recent test output:\n" + recent.map { |line| "  - #{line}" }.join("\n")
+          end
+        end
+      rescue
+        "- Fix-forward harness executed successfully."
+      end
+
+      def extract_pr_url(output)
+        output.to_s.split("\n").reverse.find { |line| line.include?("http") } || output
+      end
+
+      def run_git(args, allow_failure: false)
+        stdout, stderr, status = Open3.capture3("git", *Array(args))
+        raise "git #{args.join(" ")} failed: #{stderr.strip}" unless status.success? || allow_failure
+        stdout
+      end
+
+      def plan_value(plan_data, key)
+        return nil unless plan_data
+
+        symbol_key = key.to_sym
+        string_key = key.to_s
+        plan_data[symbol_key] || plan_data[string_key]
+      end
+    end
+  end
+end

data/lib/aidp/watch/plan_generator.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require "json"
+
+require_relative "../message_display"
+require_relative "../harness/config_manager"
+require_relative "../provider_manager"
+
+module Aidp
+  module Watch
+    # Generates implementation plans for issues during watch mode. Attempts to
+    # use a configured provider for high quality output and falls back to a
+    # deterministic heuristic plan when no provider can be invoked.
+    class PlanGenerator
+      include Aidp::MessageDisplay
+
+      PROVIDER_PROMPT = <<~PROMPT
+        You are AIDP's planning specialist. Read the GitHub issue and existing comments.
+        Produce a concise implementation contract describing the plan for the aidp agent.
+        Respond in JSON with the following shape (no extra text, no code fences):
+        {
+          "plan_summary": "one paragraph summary of what will be implemented",
+          "plan_tasks": ["task 1", "task 2", "..."],
+          "clarifying_questions": ["question 1", "question 2"]
+        }
+        Focus on concrete engineering tasks. Ensure questions are actionable.
+      PROMPT
+
+      def initialize(provider_name: nil)
+        @provider_name = provider_name
+      end
+
+      def generate(issue)
+        provider = resolve_provider
+        if provider
+          generate_with_provider(provider, issue)
+        else
+          display_message("⚠️  No active provider available. Falling back to heuristic plan.", type: :warn)
+          heuristic_plan(issue)
+        end
+      rescue => e
+        display_message("⚠️  Plan generation failed (#{e.message}). Using heuristic.", type: :warn)
+        heuristic_plan(issue)
+      end
+
+      private
+
+      def resolve_provider
+        provider_name = @provider_name || detect_default_provider
+        return nil unless provider_name
+
+        provider = Aidp::ProviderManager.get_provider(provider_name, use_harness: false)
+        return provider if provider&.available?
+
+        nil
+      rescue => e
+        display_message("⚠️  Failed to resolve provider #{provider_name}: #{e.message}", type: :warn)
+        nil
+      end
+
+      def detect_default_provider
+        config_manager = Aidp::Harness::ConfigManager.new(Dir.pwd)
+        config_manager.default_provider || "cursor"
+      rescue
+        "cursor"
+      end
+
+      def generate_with_provider(provider, issue)
+        payload = build_prompt(issue)
+        response = provider.send(prompt: payload)
+        parsed = parse_structured_response(response)
+
+        return parsed if parsed
+
+        display_message("⚠️  Unable to parse provider response. Using heuristic plan.", type: :warn)
+        heuristic_plan(issue)
+      end
+
+      def build_prompt(issue)
+        comments_text = issue[:comments]
+          .sort_by { |comment| comment["createdAt"].to_s }
+          .map do |comment|
+            author = comment["author"] || "unknown"
+            body = comment["body"] || ""
+            "#{author}:\n#{body}"
+          end
+          .join("\n\n")
+
+        <<~PROMPT
+          #{PROVIDER_PROMPT}
+
+          Issue Title: #{issue[:title]}
+          Issue URL: #{issue[:url]}
+
+          Issue Body:
+          #{issue[:body]}
+
+          Existing Comments:
+          #{comments_text}
+        PROMPT
+      end
+
+      def parse_structured_response(response)
+        text = response.to_s.strip
+        candidate = extract_json_payload(text)
+        return nil unless candidate
+
+        data = JSON.parse(candidate)
+        {
+          summary: data["plan_summary"].to_s.strip,
+          tasks: Array(data["plan_tasks"]).map(&:to_s),
+          questions: Array(data["clarifying_questions"]).map(&:to_s)
+        }
+      rescue JSON::ParserError
+        nil
+      end
+
+      def extract_json_payload(text)
+        return text if text.start_with?("{") && text.end_with?("}")
+
+        if text =~ /```json\s*(\{.*\})\s*```/m
+          return $1
+        end
+
+        json_match = text.match(/\{.*\}/m)
+        json_match ? json_match[0] : nil
+      end
+
+      def heuristic_plan(issue)
+        body = issue[:body].to_s
+        bullet_tasks = body.lines
+          .map(&:strip)
+          .select { |line| line.start_with?("-", "*") }
+          .map { |line| line.sub(/\A[-*]\s*/, "") }
+          .uniq
+          .first(5)
+
+        paragraphs = body.split(/\n{2,}/).map(&:strip).reject(&:empty?)
+        summary = paragraphs.first(2).join(" ")
+        summary = summary.empty? ? "Implement the requested changes described in the issue." : summary
+
+        tasks = if bullet_tasks.empty?
+          [
+            "Review the repository context and identify impacted components.",
+            "Implement the necessary code changes and add tests.",
+            "Document the changes and ensure lint/test pipelines succeed."
+          ]
+        else
+          bullet_tasks
+        end
+
+        questions = [
+          "Are there constraints (framework versions, performance budgets) we must respect?",
+          "Are there existing tests or acceptance criteria we should extend?",
+          "Is there additional context (design docs, related issues) we should review?"
+        ]
+
+        {
+          summary: summary,
+          tasks: tasks,
+          questions: questions
+        }
+      end
+    end
+  end
+end

data/lib/aidp/watch/plan_processor.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative "../message_display"
+require_relative "plan_generator"
+require_relative "state_store"
+
+module Aidp
+  module Watch
+    # Handles the aidp-plan label trigger by generating an implementation plan
+    # and posting it back to the originating GitHub issue.
+    class PlanProcessor
+      include Aidp::MessageDisplay
+
+      PLAN_LABEL = "aidp-plan"
+      COMMENT_HEADER = "## 🤖 AIDP Plan Proposal"
+
+      def initialize(repository_client:, state_store:, plan_generator:)
+        @repository_client = repository_client
+        @state_store = state_store
+        @plan_generator = plan_generator
+      end
+
+      def process(issue)
+        number = issue[:number]
+        if @state_store.plan_processed?(number)
+          display_message("ℹ️  Plan for issue ##{number} already posted. Skipping.", type: :muted)
+          return
+        end
+
+        display_message("🧠 Generating plan for issue ##{number} (#{issue[:title]})", type: :info)
+        plan_data = @plan_generator.generate(issue)
+
+        comment_body = build_comment(issue: issue, plan: plan_data)
+        @repository_client.post_comment(number, comment_body)
+
+        display_message("💬 Posted plan comment for issue ##{number}", type: :success)
+        @state_store.record_plan(number, plan_data.merge(comment_body: comment_body, comment_hint: COMMENT_HEADER))
+      end
+
+      private
+
+      def build_comment(issue:, plan:)
+        summary = plan[:summary].to_s.strip
+        tasks = Array(plan[:tasks])
+        questions = Array(plan[:questions])
+
+        parts = []
+        parts << COMMENT_HEADER
+        parts << ""
+        parts << "**Issue**: [##{issue[:number]}](#{issue[:url]})"
+        parts << "**Title**: #{issue[:title]}"
+        parts << ""
+        parts << "### Plan Summary"
+        parts << (summary.empty? ? "_No summary generated_" : summary)
+        parts << ""
+        parts << "### Proposed Tasks"
+        parts << format_bullets(tasks, placeholder: "_Pending task breakdown_")
+        parts << ""
+        parts << "### Clarifying Questions"
+        parts << format_numbered(questions, placeholder: "_No questions identified_")
+        parts << ""
+        parts << "Please reply inline with answers to the questions above. Once the discussion is resolved, apply the `aidp-build` label to begin implementation."
+        parts.join("\n")
+      end
+
+      def format_bullets(items, placeholder:)
+        if items.empty?
+          placeholder
+        else
+          items.map { |item| "- #{item}" }.join("\n")
+        end
+      end
+
+      def format_numbered(items, placeholder:)
+        if items.empty?
+          placeholder
+        else
+          items.each_with_index.map { |item, index| "#{index + 1}. #{item}" }.join("\n")
+        end
+      end
+    end
+  end
+end