soba-cli 0.1.0

data/lib/soba/services/tmux_session_manager.rb

@@ -0,0 +1,251 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object/blank'
+require_relative '../configuration'
+require_relative '../infrastructure/lock_manager'
+require_relative '../infrastructure/tmux_client'
+require_relative 'test_process_manager'
+
+module Soba
+  module Services
+    class TmuxSessionManager
+      def initialize(config: nil, tmux_client: nil, lock_manager: nil, test_process_manager: nil)
+        @config = config
+        @tmux_client = tmux_client || Soba::Infrastructure::TmuxClient.new
+        @lock_manager = lock_manager || Soba::Infrastructure::LockManager.new
+        @test_process_manager = test_process_manager || TestProcessManager.new
+      end
+
+      def find_or_create_repository_session
+        repository = Configuration.config.github.repository
+
+        return { success: false, error: 'Repository configuration not found' } if repository.blank?
+
+        # Convert repository name to session-safe format with PID
+        session_name = generate_session_name(repository)
+
+        if @tmux_client.session_exists?(session_name)
+          { success: true, session_name: session_name, created: false }
+        else
+          if @tmux_client.create_session(session_name)
+            { success: true, session_name: session_name, created: true }
+          else
+            { success: false, error: 'Failed to create repository session' }
+          end
+        end
+      end
+
+      def find_repository_session
+        repository = Configuration.config.github.repository
+
+        return { success: false, error: 'Repository configuration not found' } if repository.blank?
+
+        # Convert repository name to session-safe format with PID
+        session_name = generate_session_name(repository)
+
+        if @tmux_client.session_exists?(session_name)
+          { success: true, session_name: session_name, exists: true }
+        else
+          { success: true, session_name: session_name, exists: false }
+        end
+      end
+
+      def create_issue_window(session_name:, issue_number:)
+        window_name = "issue-#{issue_number}"
+        lock_name = "window-#{session_name}-#{window_name}"
+
+        @lock_manager.with_lock(lock_name, timeout: 5) do
+          # Double check for existing window to prevent duplicates
+          if @tmux_client.window_exists?(session_name, window_name)
+            { success: true, window_name: window_name, created: false }
+          else
+            if @tmux_client.create_window(session_name, window_name)
+              # Verify creation was successful
+              if @tmux_client.window_exists?(session_name, window_name)
+                { success: true, window_name: window_name, created: true }
+              else
+                { success: false, error: "Window creation verification failed for issue #{issue_number}" }
+              end
+            else
+              { success: false, error: "Failed to create window for issue #{issue_number}" }
+            end
+          end
+        end
+      rescue Soba::Infrastructure::LockTimeoutError => e
+        { success: false, error: "Lock acquisition failed: #{e.message}" }
+      end
+
+      def create_phase_pane(session_name:, window_name:, phase:, vertical: true, max_panes: 3, max_retries: 3)
+        # 前提条件チェック
+        unless @tmux_client.session_exists?(session_name)
+          return { success: false, error: "Session does not exist: #{session_name}" }
+        end
+
+        unless @tmux_client.window_exists?(session_name, window_name)
+          return { success: false, error: "Window does not exist: #{window_name}" }
+        end
+
+        # tmuxサーバーの応答性チェック
+        if @tmux_client.list_sessions.nil?
+          return { success: false, error: 'tmux server is not responding' }
+        end
+
+        # 現在のペイン一覧を取得
+        existing_panes = @tmux_client.list_panes(session_name, window_name)
+
+        # 最大ペイン数を超えている場合、古いペインを削除
+        if existing_panes.size >= max_panes
+          # start_timeでソート（古い順）
+          sorted_panes = existing_panes.sort_by { |p| p[:start_time] }
+
+          # 最大ペイン数-1になるまで古いペインを削除
+          panes_to_remove = sorted_panes.take(existing_panes.size - max_panes + 1)
+          panes_to_remove.each do |pane|
+            @tmux_client.kill_pane(pane[:id])
+          end
+        end
+
+        # リトライロジック付きでペインを作成
+        pane_id = nil
+        error_details = nil
+        retry_count = 0
+        retry_delays = [0.5, 1, 2] # 指数バックオフ
+
+        max_retries.times do |attempt|
+          result = @tmux_client.split_window(
+            session_name: session_name,
+            window_name: window_name,
+            vertical: vertical
+          )
+
+          # 結果を確認
+          if result.is_a?(Array)
+            pane_id, error_details = result
+          else
+            pane_id = result
+          end
+
+          if pane_id
+            # 成功した場合はループを抜ける
+            break
+          else
+            retry_count = attempt + 1
+            if error_details && retry_count < max_retries
+              Soba.logger.warn(
+                "Pane creation failed (attempt #{retry_count}/#{max_retries}): " \
+                "#{error_details[:stderr]} (exit status: #{error_details[:exit_status]})"
+              )
+              sleep(retry_delays[attempt] || 2)
+            end
+          end
+        end
+
+        if pane_id
+          # レイアウトを調整
+          @tmux_client.select_layout(session_name, window_name, 'even-horizontal')
+
+          { success: true, pane_id: pane_id, phase: phase }
+        else
+          error_message = "Failed to create pane for phase #{phase}"
+          if error_details
+            error_message += ": #{error_details[:stderr]}"
+            Soba.logger.error(
+              "Pane creation failed after #{retry_count} retries: " \
+              "#{error_details[:stderr]} (exit status: #{error_details[:exit_status]})"
+            )
+          end
+          { success: false, error: error_message }
+        end
+      end
+
+      def find_issue_window(repository_name, issue_number)
+        session_name = generate_session_name(repository_name)
+        window_name = "issue-#{issue_number}"
+
+        if @tmux_client.session_exists?(session_name) && @tmux_client.window_exists?(session_name, window_name)
+          "#{session_name}:#{window_name}"
+        else
+          nil
+        end
+      end
+
+      def list_issue_windows(repository_name)
+        session_name = generate_session_name(repository_name)
+
+        return [] unless @tmux_client.session_exists?(session_name)
+
+        windows = @tmux_client.list_windows(session_name)
+        issue_windows = windows.select { |window| window.start_with?('issue-') }
+
+        issue_windows.map do |window|
+          issue_number = begin
+                           window.match(/issue-(\d+)/)[1]
+                         rescue
+                           nil
+                         end
+          next unless issue_number
+
+          # Try to fetch issue title from GitHub
+          title = begin
+                    fetch_issue_title(repository_name, issue_number)
+                  rescue
+                    nil
+                  end
+
+          {
+            window: window,
+            title: title,
+          }
+        end.compact
+      end
+
+      # Check if a session exists
+      def session_exists?(session_name)
+        @tmux_client.session_exists?(session_name)
+      end
+
+      # Find repository session by PID
+      def find_repository_session_by_pid(repository)
+        require_relative 'pid_manager'
+
+        # Get PID file path for this repository
+        pid_file = File.join(Dir.home, '.soba', 'pids', "#{repository.gsub('/', '-')}.pid")
+        pid_manager = PidManager.new(pid_file)
+
+        pid = pid_manager.read
+
+        unless pid
+          return { success: true, session_name: nil, exists: false }
+        end
+
+        # Generate session name with PID
+        session_name = "soba-#{repository.gsub(/[\/._]/, '-')}-#{pid}"
+
+        if @tmux_client.session_exists?(session_name)
+          { success: true, session_name: session_name, exists: true }
+        else
+          # Clean up stale PID file
+          pid_manager.delete
+          { success: true, session_name: nil, exists: false }
+        end
+      end
+
+      private
+
+      # Generate session name without PID for simplicity
+      def generate_session_name(repository)
+        if @test_process_manager.test_mode?
+          @test_process_manager.generate_test_session_name(repository)
+        else
+          "soba-#{repository.gsub(/[\/._]/, '-')}"
+        end
+      end
+
+      def fetch_issue_title(repository_name, issue_number)
+        # This is a placeholder - actual implementation would use GitHub API
+        # For now, return nil to let the command handle it
+        nil
+      end
+    end
+  end
+end

data/lib/soba/services/workflow_blocking_checker.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Soba
+  module Services
+    class WorkflowBlockingChecker
+      ACTIVE_LABELS = %w(
+        soba:queued
+        soba:planning
+        soba:ready
+        soba:doing
+        soba:reviewing
+        soba:revising
+      ).freeze
+
+      INTERMEDIATE_LABELS = %w(
+        soba:review-requested
+        soba:requires-changes
+        soba:done
+        soba:merged
+      ).freeze
+
+      attr_reader :github_client, :logger
+
+      def initialize(github_client:, logger: nil)
+        @github_client = github_client
+        @logger = logger || SemanticLogger["WorkflowBlockingChecker"]
+      end
+
+      def blocking?(repository, issues:, except_issue_number: nil)
+        !blocking_issues(repository, issues: issues, except_issue_number: except_issue_number).empty?
+      end
+
+      def blocking_issues(repository, issues:, except_issue_number: nil)
+        # 引数で渡されたissuesからACTIVE_LABELSまたはINTERMEDIATE_LABELSを持つものを検出
+        # except_issue_numberが指定されている場合は、そのissueを除外
+        blocking = issues.select do |issue|
+          if except_issue_number && issue.number == except_issue_number
+            next false
+          end
+
+          issue.labels.any? do |label|
+            label_name = label.is_a?(Hash) ? label[:name] : label.name
+            ACTIVE_LABELS.include?(label_name) || INTERMEDIATE_LABELS.include?(label_name)
+          end
+        end
+
+        logger&.debug("Found #{blocking.size} blocking issues with ACTIVE_LABELS or INTERMEDIATE_LABELS")
+        blocking.each do |issue|
+          labels = issue.labels.map { |l| l.is_a?(Hash) ? l[:name] : l.name }.
+            select { |n| ACTIVE_LABELS.include?(n) || INTERMEDIATE_LABELS.include?(n) }
+          logger&.debug("Issue ##{issue.number}: #{labels.join(', ')}")
+        end
+
+        blocking.compact.uniq { |issue| issue.number }
+      end
+
+      def blocking_reason(repository, issues:, except_issue_number: nil)
+        blocking = blocking_issues(repository, issues: issues, except_issue_number: except_issue_number)
+        return nil if blocking.empty?
+
+        issue = blocking.first
+        label = issue.labels.find do |l|
+          label_name = l.is_a?(Hash) ? l[:name] : l.name
+          ACTIVE_LABELS.include?(label_name) || INTERMEDIATE_LABELS.include?(label_name)
+        end
+        return nil unless label
+
+        label_name = label.is_a?(Hash) ? label[:name] : label.name
+        "Issue ##{issue.number} が #{label_name} のため、新しいワークフローの開始をスキップしました"
+      end
+    end
+  end
+end

data/lib/soba/services/workflow_executor.rb

@@ -0,0 +1,256 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'shellwords'
+require_relative 'git_workspace_manager'
+require_relative 'slack_notifier'
+require_relative '../configuration'
+require_relative '../config_loader'
+
+module Soba
+  module Services
+    class WorkflowExecutionError < StandardError; end
+
+    class WorkflowExecutor
+      def initialize(tmux_session_manager: nil, git_workspace_manager: nil)
+        @tmux_session_manager = tmux_session_manager
+        @git_workspace_manager = git_workspace_manager || GitWorkspaceManager.new
+      end
+
+      def execute(phase:, issue_number:, use_tmux: true, setup_workspace: true, issue_title: nil, phase_name: nil)
+        return nil unless phase.command
+
+        # Slack通知を送信（設定が有効な場合）
+        send_slack_notification(issue_number, issue_title, phase_name) if phase_name
+
+        # フェーズ開始時にmainブランチを更新し、ワークスペースをセットアップ
+        if setup_workspace
+          # mainブランチを最新化
+          begin
+            @git_workspace_manager.update_main_branch
+            puts "Successfully updated main branch"
+          rescue GitWorkspaceManager::GitOperationError => e
+            puts "Warning: Failed to update main branch: #{e.message}"
+            puts "  Continuing without main branch update..."
+            # mainブランチの更新に失敗しても続行（エラーハンドリング）
+          end
+
+          # ワークスペースをセットアップ
+          begin
+            @git_workspace_manager.setup_workspace(issue_number)
+            puts "Successfully setup workspace for issue ##{issue_number}"
+          rescue GitWorkspaceManager::GitOperationError => e
+            puts "Warning: Failed to setup workspace: #{e.message}"
+            puts "  Continuing without worktree setup..."
+            # ワークスペースのセットアップに失敗しても続行（既存の動作を維持）
+          end
+        end
+
+        if use_tmux
+          execute_in_tmux(phase: phase, issue_number: issue_number)
+        else
+          execute_direct(phase: phase, issue_number: issue_number)
+        end
+      end
+
+      def execute_direct(phase:, issue_number:)
+        return nil unless phase.command
+
+        command_array = build_command(phase, issue_number)
+        worktree_path = @git_workspace_manager.get_worktree_path(issue_number)
+
+        result = if worktree_path
+                   # worktreeが存在する場合はその中で実行
+                   Dir.chdir(worktree_path) do
+                     Open3.popen3(*command_array) do |stdin, stdout, stderr, wait_thr|
+                       stdin.close
+                       [stdout.read, stderr.read, wait_thr.value]
+                     end
+                   end
+                 else
+                   # worktreeが存在しない場合は現在のディレクトリで実行
+                   Open3.popen3(*command_array) do |stdin, stdout, stderr, wait_thr|
+                     stdin.close
+                     [stdout.read, stderr.read, wait_thr.value]
+                   end
+                 end
+
+        stdout, stderr, status = result
+
+        {
+          success: status.exitstatus == 0,
+          output: stdout,
+          error: stderr,
+          exit_code: status.exitstatus,
+        }
+      rescue Errno::ENOENT => e
+        raise WorkflowExecutionError, "Failed to execute workflow command: #{e.message}"
+      rescue StandardError => e
+        raise WorkflowExecutionError, "Failed to execute workflow command: #{e.message}"
+      end
+
+      def execute_in_tmux(phase:, issue_number:)
+        return nil unless phase.command
+
+        command_string = build_command_string_with_worktree(phase, issue_number)
+        puts "Executing in tmux for phase: #{phase.name || 'unknown'}, issue ##{issue_number}"
+
+        begin
+          # 新しいtmux管理方式: 1リポジトリ = 1セッション、1 Issue = 1 window
+          session_result = @tmux_session_manager.find_or_create_repository_session
+          return session_result unless session_result[:success]
+
+          window_result = @tmux_session_manager.create_issue_window(
+            session_name: session_result[:session_name],
+            issue_number: issue_number
+          )
+          return window_result unless window_result[:success]
+
+          # フェーズごとにpane分割（既存のwindowがある場合は新規pane作成）
+          if window_result[:created]
+            # 新規windowの場合は最初のpaneでコマンド実行
+            puts "  Created new window: #{window_result[:window_name]}"
+            apply_command_delay
+            tmux_client = Soba::Infrastructure::TmuxClient.new
+            tmux_client.send_keys("#{session_result[:session_name]}:#{window_result[:window_name]}", command_string)
+            pane_id = nil
+          else
+            # 既存windowの場合は新規paneを作成（水平分割）
+            phase_name = phase.name || 'unknown'
+            puts "  Creating new pane for phase: #{phase_name} in window: #{window_result[:window_name]}"
+            pane_result = @tmux_session_manager.create_phase_pane(
+              session_name: session_result[:session_name],
+              window_name: window_result[:window_name],
+              phase: phase_name,
+              vertical: false
+            )
+            return pane_result unless pane_result[:success]
+
+            apply_command_delay
+            pane_id = pane_result[:pane_id]
+            puts "  Created pane: #{pane_id}"
+            tmux_client = Soba::Infrastructure::TmuxClient.new
+            tmux_client.send_keys(pane_id, command_string)
+          end
+
+          # 監視用コマンドを生成
+          target = pane_id || "#{session_result[:session_name]}:#{window_result[:window_name]}"
+          monitor_commands = [
+            "tmux attach -t #{target}",
+            "tmux capture-pane -t #{target} -p",
+          ]
+
+          {
+            success: true,
+            session_name: session_result[:session_name],
+            window_name: window_result[:window_name],
+            pane_id: pane_id,
+            mode: 'tmux',
+            tmux_info: {
+              session: session_result[:session_name],
+              window: window_result[:window_name],
+              pane: pane_id,
+              monitor_commands: monitor_commands,
+            },
+          }
+        rescue Soba::Infrastructure::TmuxNotInstalled => e
+          # tmuxがインストールされていない場合は通常実行にフォールバック
+          puts "Warning: #{e.message}. Falling back to direct execution..."
+          execute_direct(phase: phase, issue_number: issue_number)
+        rescue StandardError => e
+          # その他のtmuxエラーの場合も通常実行にフォールバック
+          puts "Warning: Tmux execution failed: #{e.message}. Falling back to direct execution..."
+          execute_direct(phase: phase, issue_number: issue_number)
+        end
+      end
+
+      private
+
+      def send_slack_notification(issue_number, issue_title, phase_name)
+        return unless Configuration.config.slack.notifications_enabled
+
+        notifier = SlackNotifier.from_config
+        return unless notifier&.enabled?
+
+        Soba.logger.debug "Sending Slack notification for phase '#{phase_name}' of issue ##{issue_number}"
+
+        result = notifier.notify_phase_start(
+          number: issue_number,
+          title: issue_title || "Issue ##{issue_number}",
+          phase: phase_name,
+          repository: Configuration.config.github.repository
+        )
+
+        if result
+          Soba.logger.debug "Successfully sent Slack notification for phase '#{phase_name}'"
+        else
+          Soba.logger.debug "Failed to send Slack notification for phase '#{phase_name}'"
+        end
+      rescue StandardError => e
+        Soba.logger.warn "Failed to send Slack notification: #{e.message}"
+      end
+
+      def build_command(phase_config, issue_number)
+        command = [phase_config.command]
+        command.concat(phase_config.options) if phase_config.options&.any?
+
+        if phase_config.parameter
+          parameter = phase_config.parameter.gsub('{{issue-number}}', issue_number.to_s)
+          command << parameter
+        end
+
+        command
+      end
+
+      def build_command_string(phase_config, issue_number)
+        command_parts = build_command(phase_config, issue_number)
+
+        # コマンドは最初の要素
+        result = [command_parts[0]]
+
+        # オプションが存在する場合（コマンド、オプション、パラメータの3つ以上の要素がある場合）
+        if phase_config.options&.any?
+          result.concat(phase_config.options)
+        end
+
+        # パラメータがある場合はダブルクォートで囲む
+        if phase_config.parameter
+          parameter = phase_config.parameter.gsub('{{issue-number}}', issue_number.to_s)
+          # パラメータにスペースやスラッシュが含まれる場合はダブルクォートで囲む
+          if parameter.include?(' ') || parameter.include?('/')
+            result << "\"#{parameter}\""
+          else
+            result << parameter
+          end
+        end
+
+        result.join(' ')
+      end
+
+      def build_command_string_with_worktree(phase_config, issue_number)
+        command_string = build_command_string(phase_config, issue_number)
+        worktree_path = @git_workspace_manager.get_worktree_path(issue_number)
+
+        if worktree_path
+          "cd #{worktree_path} && #{command_string}"
+        else
+          command_string
+        end
+      end
+
+      def apply_command_delay
+        begin
+          config = Soba::Configuration.load!
+          delay = config&.workflow&.tmux_command_delay
+          delay = 3 if delay.nil?
+        rescue StandardError
+          delay = 3
+        end
+
+        if delay && delay > 0
+          sleep(delay)
+        end
+      end
+    end
+  end
+end