soba-cli 0.1.0

data/lib/soba/infrastructure/tmux_client.rb

@@ -0,0 +1,331 @@
+# frozen_string_literal: true
+
+require 'open3'
+require_relative 'errors'
+
+module Soba
+  module Infrastructure
+    class TmuxClient
+      def create_session(session_name)
+        _stdout, _stderr, status = execute_tmux_command('new-session', '-d', '-s', session_name)
+        status.exitstatus == 0
+      rescue Errno::ENOENT
+        raise TmuxNotInstalled, 'tmux is not installed or not in PATH'
+      end
+
+      def kill_session(session_name)
+        _stdout, _stderr, status = execute_tmux_command('kill-session', '-t', session_name)
+        status.exitstatus == 0
+      rescue Errno::ENOENT
+        raise TmuxNotInstalled, 'tmux is not installed or not in PATH'
+      end
+
+      def session_exists?(session_name)
+        _stdout, _stderr, status = execute_tmux_command('has-session', '-t', session_name)
+        status.exitstatus == 0
+      rescue Errno::ENOENT
+        false
+      end
+
+      def list_sessions
+        stdout, _stderr, status = execute_tmux_command('list-sessions')
+        return [] unless status.exitstatus == 0
+
+        parse_session_list(stdout)
+      rescue Errno::ENOENT
+        []
+      end
+
+      def send_keys(session_name, command)
+        _stdout, _stderr, status = execute_tmux_command('send-keys', '-t', session_name, command, 'Enter')
+        status.exitstatus == 0
+      rescue Errno::ENOENT
+        false
+      end
+
+      def capture_pane(session_name)
+        stdout, _stderr, status = execute_tmux_command('capture-pane', '-t', session_name, '-p')
+        return nil unless status.exitstatus == 0
+
+        stdout
+      rescue Errno::ENOENT
+        nil
+      end
+
+      def create_window(session_name, window_name)
+        _stdout, _stderr, status = execute_tmux_command('new-window', '-t', session_name, '-n', window_name)
+        status.exitstatus == 0
+      rescue Errno::ENOENT
+        false
+      end
+
+      def switch_window(session_name, window_name)
+        _stdout, _stderr, status = execute_tmux_command('select-window', '-t', "#{session_name}:#{window_name}")
+        status.exitstatus == 0
+      rescue Errno::ENOENT
+        false
+      end
+
+      def list_windows(session_name)
+        stdout, _stderr, status = execute_tmux_command('list-windows', '-t', session_name)
+        return [] unless status.exitstatus == 0
+
+        parse_window_list(stdout)
+      rescue Errno::ENOENT
+        []
+      end
+
+      def rename_window(session_name, old_name, new_name)
+        _stdout, _stderr, status = execute_tmux_command('rename-window', '-t', "#{session_name}:#{old_name}", new_name)
+        status.exitstatus == 0
+      rescue Errno::ENOENT
+        false
+      end
+
+      def split_pane(session_name, direction)
+        flag = direction == :horizontal ? '-h' : '-v'
+        _stdout, _stderr, status = execute_tmux_command('split-window', '-t', session_name, flag)
+        status.exitstatus == 0
+      rescue Errno::ENOENT
+        false
+      end
+
+      def select_pane(session_name, pane_index)
+        _stdout, _stderr, status = execute_tmux_command('select-pane', '-t', "#{session_name}.#{pane_index}")
+        status.exitstatus == 0
+      rescue Errno::ENOENT
+        false
+      end
+
+      def resize_pane(session_name, direction, size)
+        direction_flags = { up: '-U', down: '-D', left: '-L', right: '-R' }
+        flag = direction_flags[direction]
+        _stdout, _stderr, status = execute_tmux_command('resize-pane', '-t', session_name, flag, size.to_s)
+        status.exitstatus == 0
+      rescue Errno::ENOENT
+        false
+      end
+
+      def close_pane(session_name, pane_index)
+        _stdout, _stderr, status = execute_tmux_command('kill-pane', '-t', "#{session_name}.#{pane_index}")
+        status.exitstatus == 0
+      rescue Errno::ENOENT
+        false
+      end
+
+      def session_info(session_name)
+        format_string = '#{session_name}: #{session_windows} windows ' \
+                        '(created #{session_created_string}) [#{session_width}x#{session_height}]'
+        stdout, _stderr, status = execute_tmux_command('list-sessions', '-F', format_string)
+        return nil unless status.exitstatus == 0
+
+        parse_session_info(stdout, session_name)
+      rescue Errno::ENOENT
+        nil
+      end
+
+      def active_session
+        stdout, _stderr, status = execute_tmux_command('display-message', '-p', '#{session_name}')
+        return nil unless status.exitstatus == 0
+
+        stdout.strip
+      rescue Errno::ENOENT
+        nil
+      end
+
+      def session_attached?(session_name)
+        stdout, _stderr, status = execute_tmux_command('list-sessions', '-F', '#{session_name}: #{session_attached}',
+'-f', "#{session_name}==#{session_name}")
+        return false unless status.exitstatus == 0
+
+        parse_attached_status(stdout)
+      rescue Errno::ENOENT
+        false
+      end
+
+      def find_pane(session_name)
+        stdout, _stderr, status = execute_tmux_command('list-panes', '-t', session_name, '-F', '#{pane_id}')
+        return nil unless status.exitstatus == 0
+
+        # Return first pane ID
+        stdout.lines.first&.strip
+      rescue Errno::ENOENT
+        nil
+      end
+
+      def capture_pane_continuous(pane_id)
+        last_content = nil
+
+        loop do
+          stdout, _stderr, status = execute_tmux_command('capture-pane', '-t', pane_id, '-p', '-S', '-')
+          break unless status.exitstatus == 0
+
+          # Yield only new content
+          if last_content.nil?
+            # 初回は全体を返す
+            yield stdout unless stdout.empty?
+            last_content = stdout
+          elsif stdout != last_content && stdout.length > last_content.length
+            # コンテンツが増えた場合は差分のみを返す
+            new_lines = stdout[last_content.length..-1]
+            yield new_lines unless new_lines.empty?
+            last_content = stdout
+          elsif stdout != last_content
+            # コンテンツが変わったが短くなった場合（画面クリアなど）は全体を返す
+            yield stdout unless stdout.empty?
+            last_content = stdout
+          end
+
+          sleep 1
+        end
+      rescue Errno::ENOENT
+        nil
+      end
+
+      def list_soba_sessions
+        sessions = list_sessions
+
+        if ENV['SOBA_TEST_MODE'] == 'true'
+          # テストモードの場合は、soba-test-で始まるセッションのみを返す
+          sessions.select { |s| s.start_with?('soba-test-') }
+        else
+          # 通常モードの場合は、soba-で始まるがsoba-test-で始まらないセッションを返す
+          sessions.select { |s| s.start_with?('soba-') && !s.start_with?('soba-test-') }
+        end
+      end
+
+      def window_exists?(session_name, window_name)
+        windows = list_windows(session_name)
+        windows.include?(window_name)
+      rescue Errno::ENOENT
+        false
+      end
+
+      def split_window(session_name:, window_name:, vertical: true)
+        flag = vertical ? '-v' : '-h'
+        target = "#{session_name}:#{window_name}"
+        command_args = ['split-window', '-t', target, flag, '-P', '-F', '#{pane_id}']
+        stdout, stderr, status = execute_tmux_command(*command_args)
+
+        if status.exitstatus == 0
+          stdout.strip
+        else
+          error_details = {
+            stderr: stderr,
+            command: ['tmux'] + command_args,
+            exit_status: status.exitstatus,
+          }
+          [nil, error_details]
+        end
+      rescue Errno::ENOENT
+        nil
+      end
+
+      def list_panes(session_name, window_name)
+        target = "#{session_name}:#{window_name}"
+        stdout, _stderr, status = execute_tmux_command(
+          'list-panes', '-t', target, '-F', '#{pane_id}:#{pane_start_time}'
+        )
+        return [] unless status.exitstatus == 0
+
+        stdout.lines.map do |line|
+          parts = line.strip.split(':')
+          { id: parts[0], start_time: parts[1].to_i }
+        end
+      rescue Errno::ENOENT
+        []
+      end
+
+      def kill_pane(pane_id)
+        _stdout, _stderr, status = execute_tmux_command('kill-pane', '-t', pane_id)
+        status.exitstatus == 0
+      rescue Errno::ENOENT
+        false
+      end
+
+      def select_layout(session_name, window_name, layout)
+        target = "#{session_name}:#{window_name}"
+        _stdout, _stderr, status = execute_tmux_command('select-layout', '-t', target, layout)
+        status.exitstatus == 0
+      rescue Errno::ENOENT
+        false
+      end
+
+      def kill_window(session_name, window_name)
+        target = "#{session_name}:#{window_name}"
+        _stdout, _stderr, status = execute_tmux_command('kill-window', '-t', target)
+        status.exitstatus == 0
+      rescue Errno::ENOENT
+        false
+      end
+
+      def tmux_installed?
+        _stdout, _stderr, _status = execute_tmux_command('list-sessions')
+        true
+      rescue Errno::ENOENT
+        false
+      end
+
+      def attach_to_window(window_id)
+        # Use system call to attach to tmux session
+        system("tmux", "attach-session", "-t", window_id)
+      rescue Errno::ENOENT
+        false
+      end
+
+      def attach_to_session(session_name)
+        # Use system call to attach to tmux session
+        system("tmux", "attach-session", "-t", session_name)
+      rescue Errno::ENOENT
+        false
+      end
+
+      private
+
+      def execute_tmux_command(*args)
+        Open3.capture3('tmux', *args)
+      end
+
+      def parse_session_list(output)
+        output.lines.map { |line| line.split(':').first }.compact
+      end
+
+      def parse_window_list(output)
+        output.lines.map do |line|
+          # Handle both active (*) and inactive (-) window markers
+          match = line.match(/^\d+:\s+(\S+?)[\*\-]?\s/)
+          match[1] if match
+        end.compact
+      end
+
+      def parse_session_info(output, session_name)
+        output.lines.each do |line|
+          if line.start_with?("#{session_name}:")
+            # Handle both single line and multi-line formats
+            combined_line = output.strip.gsub("\n", " ")
+            match = combined_line.match(/^(.+?):\s+(\d+)\s+windows?\s+\(created\s+(.+?)\)\s*\[(\d+)x(\d+)\]/)
+            if match
+              return {
+                name: match[1],
+                windows: match[2].to_i,
+                created_at: match[3],
+                size: [match[4].to_i, match[5].to_i],
+              }
+            end
+          end
+        end
+        nil
+      end
+
+      def parse_attached_status(output)
+        return false if output.empty?
+
+        line = output.lines.first.strip
+        match = line.match(/:\s+(\d+)$/)
+        return false unless match
+
+        match[1] == '1'
+      end
+    end
+  end
+end

data/lib/soba/services/ansi_processor.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Soba
+  module Services
+    # ANSIエスケープシーケンスとコントロール文字の処理
+    class AnsiProcessor
+      def initialize(preserve_colors: false, strip_codes: true, convert_to_paint: false)
+        @preserve_colors = preserve_colors
+        @strip_codes = strip_codes
+        @convert_to_paint = convert_to_paint
+      end
+
+      # テキストを処理
+      def process(text)
+        return "" if text.blank?
+
+        processed = text.dup
+
+        if @strip_codes
+          processed = strip_ansi_codes(processed)
+        elsif @convert_to_paint
+          processed = convert_to_paint_format(processed)
+          return processed # Paint形式の場合はcontrol文字処理をスキップ
+        end
+
+        handle_control_chars(processed)
+      end
+
+      private
+
+      # ANSIエスケープシーケンスを削除
+      def strip_ansi_codes(text)
+        # CSI sequences (色、カーソル移動など)
+        text = text.gsub(/\e\[[0-9;]*[a-zA-Z]/, "")
+
+        # OSC sequences (ターミナルタイトルなど)
+        text = text.gsub(/\e\][^\a]*\a/, "")
+
+        # その他のエスケープシーケンス
+        text = text.gsub(/\e\[[\?!][0-9;]*[a-zA-Z]/, "")
+
+        text
+      end
+
+      # Paint gem形式に変換（実装例）
+      def convert_to_paint_format(text)
+        # 簡易的な実装例
+        # 実際にはPaint gemのAPIに合わせて実装
+        text.gsub(/\e\[31m(.*?)\e\[0m/, '[[\1]]')
+      end
+
+      # コントロール文字の処理
+      def handle_control_chars(text)
+        lines = text.split("\n")
+
+        lines.map! do |line|
+          # キャリッジリターンの処理
+          if line.include?("\r")
+            parts = line.split("\r")
+            # 最後の部分が現在の行
+            current = parts.last || ""
+
+            # 前の部分があれば、現在の行で上書き
+            if parts.size > 1 && parts[-2]
+              prev = parts[-2]
+              if current.length < prev.length
+                # 現在の行が短い場合、前の行の残りを追加
+                current += prev[current.length..-1].to_s
+              end
+            end
+
+            line = current
+          end
+
+          # バックスペースの処理
+          while line.include?("\b")
+            idx = line.index("\b")
+            if idx && idx > 0
+              line = line[0...idx - 1] + line[idx + 1..-1].to_s
+            else
+              line = line.sub("\b", "")
+            end
+          end
+
+          line
+        end
+
+        lines.join("\n")
+      end
+    end
+  end
+end

data/lib/soba/services/auto_merge_service.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require "semantic_logger"
+require_relative "../infrastructure/github_client"
+require_relative "../configuration"
+
+module Soba
+  module Services
+    class AutoMergeService
+      include SemanticLogger::Loggable
+
+      def initialize
+        @github_client = Infrastructure::GitHubClient.new
+        @repository = Configuration.config.github.repository
+      end
+
+      def execute
+        logger.info "Starting auto-merge process", repository: @repository
+
+        approved_prs = find_approved_prs
+
+        if approved_prs.empty?
+          logger.info "No PRs with soba:lgtm label found"
+          return {
+            merged_count: 0,
+            failed_count: 0,
+            details: { merged: [], failed: [] },
+          }
+        end
+
+        logger.info "Found approved PRs", count: approved_prs.size, pr_numbers: approved_prs.map { |pr| pr[:number] }
+
+        merged = []
+        failed = []
+
+        approved_prs.each do |pr|
+          pr_number = pr[:number]
+          logger.info "Processing PR", pr_number: pr_number, title: pr[:title]
+
+          begin
+            if check_mergeable(pr_number)
+              result = perform_merge(pr_number)
+              if result[:merged]
+                handle_post_merge(pr_number)
+                merged << { number: pr_number, title: pr[:title], sha: result[:sha] }
+                logger.info "PR merged successfully", pr_number: pr_number, sha: result[:sha]
+              else
+                failed << { number: pr_number, title: pr[:title], reason: "Merge returned false" }
+                logger.warn "PR merge returned false", pr_number: pr_number
+              end
+            else
+              failed << { number: pr_number, title: pr[:title], reason: "PR is not mergeable (conflicts or CI issues)" }
+              logger.warn "PR is not mergeable", pr_number: pr_number
+            end
+          rescue Infrastructure::MergeConflictError => e
+            failed << { number: pr_number, title: pr[:title], reason: e.message }
+            logger.error "Merge conflict error", pr_number: pr_number, error: e.message
+          rescue => e
+            failed << { number: pr_number, title: pr[:title], reason: e.message }
+            logger.error "Unexpected error during merge", pr_number: pr_number, error: e.message,
+                                                          backtrace: e.backtrace.first(5)
+          end
+        end
+
+        logger.info "Auto-merge process completed",
+                    merged_count: merged.size,
+                    failed_count: failed.size
+
+        {
+          merged_count: merged.size,
+          failed_count: failed.size,
+          details: {
+            merged: merged,
+            failed: failed,
+          },
+        }
+      end
+
+      private
+
+      def find_approved_prs
+        logger.debug "Searching for PRs with soba:lgtm label"
+        @github_client.search_pull_requests(repository: @repository, labels: ["soba:lgtm"])
+      rescue => e
+        logger.error "Failed to find approved PRs", error: e.message
+        []
+      end
+
+      def check_mergeable(pr_number)
+        logger.debug "Checking if PR is mergeable", pr_number: pr_number
+
+        pr = @github_client.get_pull_request(@repository, pr_number)
+
+        # Check both mergeable flag and mergeable_state
+        # mergeable_state can be: "clean", "dirty", "unknown", "blocked", "behind", "unstable", "has_hooks", "draft"
+        is_mergeable = pr[:mergeable] == true && pr[:mergeable_state] == "clean"
+
+        logger.debug "PR mergeable status",
+                     pr_number: pr_number,
+                     mergeable: pr[:mergeable],
+                     mergeable_state: pr[:mergeable_state],
+                     is_mergeable: is_mergeable
+
+        is_mergeable
+      rescue => e
+        logger.error "Failed to check mergeable status", pr_number: pr_number, error: e.message
+        false
+      end
+
+      def perform_merge(pr_number)
+        logger.info "Merging PR", pr_number: pr_number, merge_method: "squash"
+
+        @github_client.merge_pull_request(@repository, pr_number, merge_method: "squash")
+      end
+
+      def handle_post_merge(pr_number)
+        logger.debug "Handling post-merge actions", pr_number: pr_number
+
+        # Extract issue number from PR body
+        issue_number = @github_client.get_pr_issue_number(@repository, pr_number)
+
+        if issue_number
+          logger.info "Closing related issue", pr_number: pr_number, issue_number: issue_number
+          @github_client.close_issue_with_label(@repository, issue_number, label: "soba:merged")
+        else
+          logger.warn "No related issue found in PR body", pr_number: pr_number
+        end
+      rescue => e
+        logger.error "Failed to handle post-merge actions", pr_number: pr_number, error: e.message
+      end
+    end
+  end
+end

data/lib/soba/services/closed_issue_window_cleaner.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Soba
+  module Services
+    class ClosedIssueWindowCleaner
+      attr_reader :github_client, :tmux_client, :logger
+
+      def initialize(github_client:, tmux_client:, logger:)
+        @github_client = github_client
+        @tmux_client = tmux_client
+        @logger = logger
+        @last_cleanup_time = nil
+        @repository = nil
+      end
+
+      def clean(session_name)
+        logger.debug("Cleaning up windows for closed issues in session: #{session_name}")
+
+        begin
+          closed_issues = fetch_closed_issues
+          if closed_issues.empty?
+            logger.debug('No closed issues found')
+            return
+          end
+
+          logger.debug("Found #{closed_issues.size} closed issues")
+
+          windows = list_tmux_windows(session_name)
+          return if windows.nil?
+
+          removed_count = 0
+          closed_issues.each do |issue|
+            window_name = "issue-#{issue.number}"
+            if windows.include?(window_name)
+              if remove_window(session_name, window_name, issue)
+                removed_count += 1
+              end
+            end
+          end
+
+          logger.debug("Cleanup completed for #{session_name}: removed #{removed_count} windows")
+        rescue StandardError => e
+          logger.error("Unexpected error during cleanup: #{e.message}")
+        end
+      end
+
+      def should_clean?
+        return false unless config.workflow.closed_issue_cleanup_enabled
+
+        if @last_cleanup_time.nil?
+          @last_cleanup_time = Time.now
+          return true
+        end
+
+        time_since_last = Time.now - @last_cleanup_time
+        if time_since_last >= config.workflow.closed_issue_cleanup_interval
+          @last_cleanup_time = Time.now
+          return true
+        end
+
+        false
+      end
+
+      private
+
+      def config
+        @config ||= Soba::Configuration.config
+      end
+
+      def fetch_closed_issues
+        repository = config.github.repository || ENV['GITHUB_REPOSITORY']
+        github_client.fetch_closed_issues(repository)
+      rescue StandardError => e
+        logger.error("Failed to fetch closed issues: #{e.message}")
+        []
+      end
+
+      def list_tmux_windows(session_name)
+        tmux_client.list_windows(session_name)
+      rescue StandardError => e
+        logger.error("Failed to list tmux windows: #{e.message}")
+        nil
+      end
+
+      def remove_window(session_name, window_name, issue)
+        if tmux_client.kill_window(session_name, window_name)
+          logger.info("Removed window: #{window_name} (Issue ##{issue.number}: #{issue.title})")
+          true
+        else
+          logger.warn("Failed to remove window: #{window_name}")
+          false
+        end
+      end
+    end
+  end
+end