aidp 0.12.1 → 0.14.0

data/lib/aidp/watch/repository_client.rb

@@ -0,0 +1,243 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "open3"
+require "uri"
+
+module Aidp
+  module Watch
+    # Lightweight adapter around GitHub for watch mode. Prefers the GitHub CLI
+    # (works for private repositories) and falls back to public REST endpoints
+    # when the CLI is unavailable.
+    class RepositoryClient
+      attr_reader :owner, :repo
+
+      def self.parse_issues_url(issues_url)
+        case issues_url
+        when %r{\Ahttps://github\.com/([^/]+)/([^/]+)(?:/issues)?/?\z}
+          [$1, $2]
+        when %r{\A([^/]+)/([^/]+)\z}
+          [$1, $2]
+        else
+          raise ArgumentError, "Unsupported issues URL: #{issues_url}"
+        end
+      end
+
+      def initialize(owner:, repo:, gh_available: nil)
+        @owner = owner
+        @repo = repo
+        @gh_available = gh_available.nil? ? gh_cli_available? : gh_available
+      end
+
+      def gh_available?
+        @gh_available
+      end
+
+      def full_repo
+        "#{owner}/#{repo}"
+      end
+
+      def list_issues(labels: [], state: "open")
+        gh_available? ? list_issues_via_gh(labels: labels, state: state) : list_issues_via_api(labels: labels, state: state)
+      end
+
+      def fetch_issue(number)
+        gh_available? ? fetch_issue_via_gh(number) : fetch_issue_via_api(number)
+      end
+
+      def post_comment(number, body)
+        gh_available? ? post_comment_via_gh(number, body) : post_comment_via_api(number, body)
+      end
+
+      def create_pull_request(title:, body:, head:, base:, issue_number:)
+        gh_available? ? create_pull_request_via_gh(title: title, body: body, head: head, base: base, issue_number: issue_number) : raise("GitHub CLI not available - cannot create PR")
+      end
+
+      private
+
+      def gh_cli_available?
+        _stdout, _stderr, status = Open3.capture3("gh", "--version")
+        status.success?
+      rescue Errno::ENOENT
+        false
+      end
+
+      def list_issues_via_gh(labels:, state:)
+        json_fields = %w[number title labels updatedAt state url assignees]
+        cmd = ["gh", "issue", "list", "--repo", full_repo, "--state", state, "--json", json_fields.join(",")]
+        labels.each do |label|
+          cmd += ["--label", label]
+        end
+
+        stdout, stderr, status = Open3.capture3(*cmd)
+        unless status.success?
+          warn("GitHub CLI list failed: #{stderr}")
+          return []
+        end
+
+        JSON.parse(stdout).map { |raw| normalize_issue(raw) }
+      rescue JSON::ParserError => e
+        warn("Failed to parse GH CLI response: #{e.message}")
+        []
+      end
+
+      def list_issues_via_api(labels:, state:)
+        label_param = labels.join(",")
+        uri = URI("https://api.github.com/repos/#{full_repo}/issues?state=#{state}")
+        uri.query = [uri.query, "labels=#{URI.encode_www_form_component(label_param)}"].compact.join("&") unless label_param.empty?
+
+        response = Net::HTTP.get_response(uri)
+        return [] unless response.code == "200"
+
+        JSON.parse(response.body).reject { |item| item["pull_request"] }.map { |raw| normalize_issue_api(raw) }
+      rescue => e
+        warn("GitHub API list failed: #{e.message}")
+        []
+      end
+
+      def fetch_issue_via_gh(number)
+        fields = %w[number title body comments labels state assignees url updatedAt author]
+        cmd = ["gh", "issue", "view", number.to_s, "--repo", full_repo, "--json", fields.join(",")]
+
+        stdout, stderr, status = Open3.capture3(*cmd)
+        raise "GitHub CLI error: #{stderr.strip}" unless status.success?
+
+        data = JSON.parse(stdout)
+        normalize_issue_detail(data)
+      rescue JSON::ParserError => e
+        raise "Failed to parse GitHub CLI issue response: #{e.message}"
+      end
+
+      def fetch_issue_via_api(number)
+        uri = URI("https://api.github.com/repos/#{full_repo}/issues/#{number}")
+        response = Net::HTTP.get_response(uri)
+        raise "GitHub API error (#{response.code})" unless response.code == "200"
+
+        data = JSON.parse(response.body)
+        comments = fetch_comments_via_api(number)
+        data["comments"] = comments
+        normalize_issue_detail_api(data)
+      end
+
+      def fetch_comments_via_api(number)
+        uri = URI("https://api.github.com/repos/#{full_repo}/issues/#{number}/comments")
+        response = Net::HTTP.get_response(uri)
+        return [] unless response.code == "200"
+
+        JSON.parse(response.body).map do |raw|
+          {
+            "body" => raw["body"],
+            "author" => raw.dig("user", "login"),
+            "createdAt" => raw["created_at"]
+          }
+        end
+      rescue
+        []
+      end
+
+      def post_comment_via_gh(number, body)
+        cmd = ["gh", "issue", "comment", number.to_s, "--repo", full_repo, "--body", body]
+        stdout, stderr, status = Open3.capture3(*cmd)
+        raise "Failed to post comment via gh: #{stderr.strip}" unless status.success?
+
+        stdout.strip
+      end
+
+      def post_comment_via_api(number, body)
+        uri = URI("https://api.github.com/repos/#{full_repo}/issues/#{number}/comments")
+        request = Net::HTTP::Post.new(uri)
+        request["Content-Type"] = "application/json"
+        request.body = JSON.dump({body: body})
+
+        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+          http.request(request)
+        end
+
+        raise "GitHub API comment failed (#{response.code})" unless response.code.start_with?("2")
+        response.body
+      end
+
+      def create_pull_request_via_gh(title:, body:, head:, base:, issue_number:)
+        cmd = [
+          "gh", "pr", "create",
+          "--repo", full_repo,
+          "--title", title,
+          "--body", body,
+          "--head", head,
+          "--base", base
+        ]
+        cmd += ["--issue", issue_number.to_s] if issue_number
+
+        stdout, stderr, status = Open3.capture3(*cmd)
+        raise "Failed to create PR via gh: #{stderr.strip}" unless status.success?
+
+        stdout.strip
+      end
+
+      def normalize_issue(raw)
+        {
+          number: raw["number"],
+          title: raw["title"],
+          labels: Array(raw["labels"]).map { |label| label.is_a?(Hash) ? label["name"] : label },
+          updated_at: raw["updatedAt"],
+          state: raw["state"],
+          url: raw["url"],
+          assignees: Array(raw["assignees"]).map { |assignee| assignee.is_a?(Hash) ? assignee["login"] : assignee }
+        }
+      end
+
+      def normalize_issue_api(raw)
+        {
+          number: raw["number"],
+          title: raw["title"],
+          labels: Array(raw["labels"]).map { |label| label["name"] },
+          updated_at: raw["updated_at"],
+          state: raw["state"],
+          url: raw["html_url"],
+          assignees: Array(raw["assignees"]).map { |assignee| assignee["login"] }
+        }
+      end
+
+      def normalize_issue_detail(raw)
+        {
+          number: raw["number"],
+          title: raw["title"],
+          body: raw["body"] || "",
+          comments: Array(raw["comments"]).map { |comment| normalize_comment(comment) },
+          labels: Array(raw["labels"]).map { |label| label.is_a?(Hash) ? label["name"] : label },
+          state: raw["state"],
+          assignees: Array(raw["assignees"]).map { |assignee| assignee.is_a?(Hash) ? assignee["login"] : assignee },
+          url: raw["url"],
+          updated_at: raw["updatedAt"]
+        }
+      end
+
+      def normalize_issue_detail_api(raw)
+        {
+          number: raw["number"],
+          title: raw["title"],
+          body: raw["body"] || "",
+          comments: Array(raw["comments"]).map { |comment| normalize_comment(comment) },
+          labels: Array(raw["labels"]).map { |label| label["name"] },
+          state: raw["state"],
+          assignees: Array(raw["assignees"]).map { |assignee| assignee["login"] },
+          url: raw["html_url"],
+          updated_at: raw["updated_at"]
+        }
+      end
+
+      def normalize_comment(comment)
+        if comment.is_a?(Hash)
+          {
+            "body" => comment["body"],
+            "author" => comment["author"] || comment.dig("user", "login"),
+            "createdAt" => comment["createdAt"] || comment["created_at"]
+          }
+        else
+          {"body" => comment.to_s}
+        end
+      end
+    end
+  end
+end

data/lib/aidp/watch/runner.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "tty-prompt"
+
+require_relative "../message_display"
+require_relative "repository_client"
+require_relative "state_store"
+require_relative "plan_generator"
+require_relative "plan_processor"
+require_relative "build_processor"
+
+module Aidp
+  module Watch
+    # Coordinates the watch mode loop: monitors issues, handles plan/build
+    # triggers, and keeps running until interrupted.
+    class Runner
+      include Aidp::MessageDisplay
+
+      DEFAULT_INTERVAL = 30
+
+      def initialize(issues_url:, interval: DEFAULT_INTERVAL, provider_name: nil, gh_available: nil, project_dir: Dir.pwd, once: false, prompt: TTY::Prompt.new)
+        @prompt = prompt
+        @interval = interval
+        @once = once
+        @project_dir = project_dir
+
+        owner, repo = RepositoryClient.parse_issues_url(issues_url)
+        @repository_client = RepositoryClient.new(owner: owner, repo: repo, gh_available: gh_available)
+        @state_store = StateStore.new(project_dir: project_dir, repository: "#{owner}/#{repo}")
+        @plan_processor = PlanProcessor.new(
+          repository_client: @repository_client,
+          state_store: @state_store,
+          plan_generator: PlanGenerator.new(provider_name: provider_name)
+        )
+        @build_processor = BuildProcessor.new(
+          repository_client: @repository_client,
+          state_store: @state_store,
+          project_dir: project_dir
+        )
+      end
+
+      def start
+        display_message("👀 Watch mode enabled for #{@repository_client.full_repo}", type: :highlight)
+        display_message("Polling every #{@interval} seconds. Press Ctrl+C to stop.", type: :muted)
+
+        loop do
+          process_cycle
+          break if @once
+          sleep @interval
+        end
+      rescue Interrupt
+        display_message("\n⏹️  Watch mode interrupted by user", type: :warning)
+      end
+
+      private
+
+      def process_cycle
+        process_plan_triggers
+        process_build_triggers
+      end
+
+      def process_plan_triggers
+        issues = @repository_client.list_issues(labels: [PlanProcessor::PLAN_LABEL], state: "open")
+        issues.each do |issue|
+          next unless issue_has_label?(issue, PlanProcessor::PLAN_LABEL)
+
+          detailed = @repository_client.fetch_issue(issue[:number])
+          @plan_processor.process(detailed)
+        end
+      end
+
+      def process_build_triggers
+        issues = @repository_client.list_issues(labels: [BuildProcessor::BUILD_LABEL], state: "open")
+        issues.each do |issue|
+          next unless issue_has_label?(issue, BuildProcessor::BUILD_LABEL)
+
+          status = @state_store.build_status(issue[:number])
+          next if status["status"] == "completed"
+
+          detailed = @repository_client.fetch_issue(issue[:number])
+          @build_processor.process(detailed)
+        end
+      end
+
+      def issue_has_label?(issue, label)
+        Array(issue[:labels]).any? do |issue_label|
+          name = issue_label.is_a?(Hash) ? issue_label["name"] : issue_label.to_s
+          name.casecmp(label).zero?
+        end
+      end
+    end
+  end
+end

data/lib/aidp/watch/state_store.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
+require "time"
+
+module Aidp
+  module Watch
+    # Persists watch mode progress for each repository/issue pair. Used to
+    # avoid re-processing plan/build triggers and to retain generated plan
+    # context between runs.
+    class StateStore
+      attr_reader :path
+
+      def initialize(project_dir:, repository:)
+        @project_dir = project_dir
+        @repository = repository
+        @path = File.join(project_dir, ".aidp", "watch", "#{sanitize_repository(repository)}.yml")
+        ensure_directory
+      end
+
+      def plan_processed?(issue_number)
+        plans.key?(issue_number.to_s)
+      end
+
+      def plan_data(issue_number)
+        plans[issue_number.to_s]
+      end
+
+      def record_plan(issue_number, data)
+        payload = {
+          "summary" => data[:summary],
+          "tasks" => data[:tasks],
+          "questions" => data[:questions],
+          "comment_body" => data[:comment_body],
+          "comment_hint" => data[:comment_hint],
+          "posted_at" => data[:posted_at] || Time.now.utc.iso8601
+        }.compact
+
+        plans[issue_number.to_s] = payload
+        save!
+      end
+
+      def build_status(issue_number)
+        builds[issue_number.to_s] || {}
+      end
+
+      def record_build_status(issue_number, status:, details: {})
+        builds[issue_number.to_s] = {
+          "status" => status,
+          "updated_at" => Time.now.utc.iso8601
+        }.merge(stringify_keys(details))
+        save!
+      end
+
+      private
+
+      def ensure_directory
+        FileUtils.mkdir_p(File.dirname(@path))
+      end
+
+      def sanitize_repository(repository)
+        repository.tr("/", "_")
+      end
+
+      def load_state
+        @state ||= if File.exist?(@path)
+          YAML.safe_load_file(@path, permitted_classes: [Time]) || {}
+        else
+          {}
+        end
+      end
+
+      def save!
+        File.write(@path, YAML.dump(state))
+      end
+
+      def state
+        @state = nil if @state && !@state.is_a?(Hash)
+        @state ||= begin
+          base = load_state
+          base["plans"] ||= {}
+          base["builds"] ||= {}
+          base
+        end
+      end
+
+      def plans
+        state["plans"]
+      end
+
+      def builds
+        state["builds"]
+      end
+
+      def stringify_keys(hash)
+        return {} unless hash
+
+        hash.each_with_object({}) do |(key, value), memo|
+          memo[key.to_s] = value
+        end
+      end
+    end
+  end
+end

data/lib/aidp/watch.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "message_display"
+require_relative "watch/repository_client"
+require_relative "watch/state_store"
+require_relative "watch/plan_generator"
+require_relative "watch/plan_processor"
+require_relative "watch/build_processor"
+require_relative "watch/runner"