soba-cli 0.1.0

data/lib/soba/services/process_info.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'English'
+module Soba
+  module Services
+    class ProcessInfo
+      attr_reader :pid
+
+      def initialize(pid)
+        @pid = pid.to_i
+      end
+
+      def memory_usage_mb
+        return nil unless exists?
+
+        memory_kb = if File.exist?("/proc/#{pid}/status")
+                      # Linux: Read from /proc filesystem
+                      memory_from_proc
+                    else
+                      # macOS/other: Use ps command
+                      memory_from_ps
+                    end
+
+        memory_kb ? (memory_kb / 1024.0).round(2) : nil
+      rescue StandardError
+        nil
+      end
+
+      def exists?
+        return false if pid <= 0
+
+        Process.kill(0, pid)
+        true
+      rescue Errno::ESRCH, Errno::EPERM
+        false
+      end
+
+      private
+
+      def memory_from_proc
+        content = File.read("/proc/#{pid}/status")
+        # Look for VmRSS (Resident Set Size) in kilobytes
+        if content =~ /VmRSS:\s+(\d+)\s+kB/
+          Regexp.last_match(1).to_i
+        end
+      end
+
+      def memory_from_ps
+        # ps -o rss= returns memory in kilobytes
+        output = `ps -o rss= -p #{pid} 2>/dev/null`.strip
+
+        if $CHILD_STATUS.success? && !output.empty?
+          output.to_i
+        end
+      end
+    end
+  end
+end

data/lib/soba/services/queueing_service.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Soba
+  module Services
+    class QueueingService
+      TODO_LABEL = "soba:todo"
+      QUEUED_LABEL = "soba:queued"
+
+      attr_reader :github_client, :blocking_checker, :logger
+
+      def initialize(github_client:, blocking_checker:, logger: nil)
+        @github_client = github_client
+        @blocking_checker = blocking_checker
+        @logger = logger || SemanticLogger["QueueingService"]
+      end
+
+      def queue_next_issue(repository)
+        logger.info("Starting queueing process: #{repository}")
+
+        if has_active_issue?(repository)
+          issues = github_client.issues(repository, state: "open")
+          reason = blocking_checker.blocking_reason(repository, issues: issues)
+          logger.info("Skipping queueing process: #{reason}")
+          return nil
+        end
+
+        candidate = find_next_candidate_from_repository(repository)
+        if candidate.nil?
+          logger.info("No issues found for queueing")
+          return nil
+        end
+
+        result = transition_to_queued(candidate, repository)
+        return nil if result.nil? # 競合状態検出時
+
+        candidate
+      rescue => e
+        logger.error("Error during queueing process: #{e.message} (repository: #{repository})")
+        raise
+      end
+
+      private
+
+      def has_active_issue?(repository)
+        issues = github_client.issues(repository, state: "open")
+        blocking_checker.blocking?(repository, issues: issues)
+      end
+
+      def find_next_candidate_from_repository(repository)
+        issues = github_client.issues(repository, state: "open")
+        find_next_candidate(issues)
+      end
+
+      def find_next_candidate(issues)
+        # アクティブまたは中間状態のsobaラベルを持つIssueが存在する場合はnilを返す
+        active_or_intermediate_issues = issues.select do |issue|
+          issue.labels.any? do |label|
+            label_name = label[:name]
+            WorkflowBlockingChecker::ACTIVE_LABELS.include?(label_name) ||
+              WorkflowBlockingChecker::INTERMEDIATE_LABELS.include?(label_name)
+          end
+        end
+
+        return nil unless active_or_intermediate_issues.empty?
+
+        todo_issues = issues.select do |issue|
+          issue.labels.any? { |label| label[:name] == TODO_LABEL }
+        end
+
+        return nil if todo_issues.empty?
+
+        # Issue番号の昇順でソートして最初の1件を返す
+        todo_issues.min_by(&:number)
+      end
+
+      def transition_to_queued(issue, repository)
+        # ラベル更新直前に再度排他制御チェック（競合状態の検出）
+        current_issues = github_client.issues(repository, state: "open")
+        if blocking_checker.blocking?(repository, issues: current_issues)
+          reason = blocking_checker.blocking_reason(repository, issues: current_issues)
+          logger.warn("Race condition detected: #{reason}")
+          logger.warn("Skipping queueing for Issue ##{issue.number}")
+          return nil
+        end
+
+        logger.debug("Updating labels for Issue ##{issue.number}: #{TODO_LABEL} -> #{QUEUED_LABEL}")
+
+        github_client.update_issue_labels(repository, issue.number, from: TODO_LABEL, to: QUEUED_LABEL)
+
+        logger.info("Transitioned Issue ##{issue.number} to soba:queued: #{issue.title}")
+        true  # 成功を示すために true を返す
+      rescue => e
+        logger.error("Failed to update labels for Issue ##{issue.number}: #{e.message}")
+        raise
+      end
+    end
+  end
+end

data/lib/soba/services/session_logger.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "time"
+
+module Soba
+  module Services
+    # セッション出力のログ管理サービス
+    class SessionLogger
+      DEFAULT_LOG_DIR = File.join(Dir.home, ".soba", "logs")
+      DEFAULT_MAX_SIZE = 10 * 1024 * 1024 # 10MB
+
+      attr_reader :log_dir
+
+      def initialize(log_dir: nil, max_size: DEFAULT_MAX_SIZE)
+        @log_dir = log_dir || DEFAULT_LOG_DIR
+        @max_size = max_size
+        @file_handles = {}
+
+        ensure_log_directory
+      end
+
+      # ログファイルに書き込み
+      def write(session_name, content)
+        ensure_file_handle(session_name)
+
+        timestamp = Time.now.strftime("[%Y-%m-%d %H:%M:%S]")
+        @file_handles[session_name].write("#{timestamp} #{content}")
+        @file_handles[session_name].flush
+
+        # ローテーションチェック
+        check_rotation(session_name)
+      end
+
+      # セッションのログファイルパスを取得
+      def find_log(session_name)
+        log_file = File.join(@log_dir, "#{session_name}.log")
+        File.exist?(log_file) ? log_file : nil
+      end
+
+      # ログが存在するセッション一覧
+      def list_sessions
+        Dir.glob(File.join(@log_dir, "soba-*.log")).
+          reject { |f| f.include?(".log.") }. # ローテートファイルを除外
+          map { |f| File.basename(f, ".log") }.
+          sort
+      end
+
+      # ファイルハンドルをクローズ
+      def close
+        @file_handles.each_value(&:close)
+        @file_handles.clear
+      end
+
+      # 古いログファイルのクリーンアップ
+      def cleanup_old_logs(days: 30)
+        cutoff_time = Time.now - (days * 24 * 60 * 60)
+
+        Dir.glob(File.join(@log_dir, "soba-*.log*")).each do |file|
+          if File.mtime(file) < cutoff_time
+            File.delete(file)
+          end
+        end
+      end
+
+      private
+
+      # ログディレクトリの確認と作成
+      def ensure_log_directory
+        FileUtils.mkdir_p(@log_dir) unless Dir.exist?(@log_dir)
+      end
+
+      # ファイルハンドルの取得または作成
+      def ensure_file_handle(session_name)
+        return if @file_handles[session_name]
+
+        log_file = File.join(@log_dir, "#{session_name}.log")
+        @file_handles[session_name] = File.open(log_file, "a")
+      end
+
+      # ログローテーションのチェック
+      def check_rotation(session_name)
+        log_file = File.join(@log_dir, "#{session_name}.log")
+        return unless File.size(log_file) > @max_size
+
+        rotate_log(session_name)
+      end
+
+      # ログファイルのローテート
+      def rotate_log(session_name)
+        log_file = File.join(@log_dir, "#{session_name}.log")
+
+        # ファイルハンドルを閉じる
+        @file_handles[session_name]&.close
+        @file_handles.delete(session_name)
+
+        # ローテート番号を決定
+        rotate_number = 1
+        while File.exist?("#{log_file}.#{rotate_number}")
+          rotate_number += 1
+        end
+
+        # ファイルを移動
+        File.rename(log_file, "#{log_file}.#{rotate_number}")
+
+        # 新しいファイルハンドルを開く
+        ensure_file_handle(session_name)
+      end
+    end
+  end
+end

data/lib/soba/services/session_resolver.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Soba
+  module Services
+    class SessionResolver
+      def initialize(pid_manager: nil, tmux_manager: nil)
+        @pid_manager = pid_manager || PidManager.new
+        @tmux_manager = tmux_manager || TmuxSessionManager.new
+      end
+
+      def resolve_active_session(repository)
+        pid = @pid_manager.read
+        return nil unless pid
+
+        session_name = generate_session_name(repository, pid)
+
+        if @tmux_manager.session_exists?(session_name)
+          session_name
+        else
+          @pid_manager.delete
+          nil
+        end
+      rescue Errno::ENOENT
+        nil
+      end
+
+      def find_all_repository_sessions(repository)
+        pid = @pid_manager.read
+        return [] unless pid
+
+        session_name = generate_session_name(repository, pid)
+        active = @tmux_manager.session_exists?(session_name)
+
+        unless active
+          @pid_manager.delete
+        end
+
+        [
+          {
+            name: session_name,
+            pid: pid,
+            active: active,
+          },
+        ]
+      end
+
+      def generate_session_name(repository, pid)
+        raise ArgumentError, "PID cannot be nil" if pid.nil?
+
+        sanitized_repo = repository.to_s.gsub(/[^a-zA-Z0-9-]/, "-")
+        "soba-#{sanitized_repo}-#{pid}"
+      end
+
+      def cleanup_stale_sessions(repository)
+        pid = @pid_manager.read
+        return [] unless pid
+
+        session_name = generate_session_name(repository, pid)
+        if @tmux_manager.session_exists?(session_name)
+          []
+        else
+          @pid_manager.delete
+          [pid]
+        end
+      end
+
+      private
+
+      attr_reader :pid_manager, :tmux_manager
+    end
+  end
+end

data/lib/soba/services/slack_notifier.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "json"
+
+module Soba
+  module Services
+    class SlackNotifier
+      def initialize(webhook_url:)
+        @webhook_url = webhook_url
+      end
+
+      def notify_phase_start(issue_data)
+        return false unless enabled?
+
+        logger.debug "Starting Slack notification for issue ##{issue_data[:number]}, phase: #{issue_data[:phase]}"
+
+        begin
+          message = build_message(issue_data)
+          logger.debug "Sending notification to Slack webhook"
+
+          response = send_notification(message)
+
+          if response.success?
+            logger.debug "Slack notification sent successfully (HTTP #{response.status})"
+            true
+          else
+            logger.warn("Failed to send Slack notification: HTTP #{response.status}")
+            false
+          end
+        rescue StandardError => e
+          logger.warn("Error sending Slack notification: #{e.message}")
+          false
+        end
+      end
+
+      def enabled?
+        @webhook_url.present?
+      end
+
+      def self.from_env
+        new(webhook_url: ENV["SLACK_WEBHOOK_URL"])
+      end
+
+      def self.from_config
+        config = Soba::Configuration.config
+        return unless config.slack.notifications_enabled
+
+        webhook_url = config.slack.webhook_url
+        # 環境変数形式の場合は展開
+        if webhook_url&.match?(/\$\{([^}]+)\}/)
+          var_name = webhook_url.match(/\$\{([^}]+)\}/)[1]
+          webhook_url = ENV[var_name]
+        end
+
+        new(webhook_url: webhook_url)
+      end
+
+      private
+
+      def send_notification(message)
+        connection = Faraday.new do |conn|
+          conn.request :json
+          conn.response :json
+          conn.adapter Faraday.default_adapter
+          conn.options.timeout = 5
+          conn.options.open_timeout = 5
+        end
+
+        connection.post(@webhook_url, message.to_json)
+      end
+
+      def build_message(issue_data)
+        issue_url = if issue_data[:repository]
+                      "https://github.com/#{issue_data[:repository]}/issues/#{issue_data[:number]}"
+                    else
+                      "##{issue_data[:number]}"
+                    end
+
+        issue_value = if issue_data[:repository]
+                        "<#{issue_url}|##{issue_data[:number]}>"
+                      else
+                        "##{issue_data[:number]}"
+                      end
+
+        {
+          text: "🚀 Soba started #{issue_data[:phase]} phase: Issue ##{issue_data[:number]}",
+          attachments: [
+            {
+              color: "good",
+              title: issue_data[:title],
+              fields: [
+                {
+                  title: "Issue",
+                  value: issue_value,
+                  short: true,
+                },
+                {
+                  title: "Phase",
+                  value: issue_data[:phase],
+                  short: true,
+                },
+              ],
+              footer: "Soba CLI",
+              footer_icon: "https://github.com/favicon.ico",
+              ts: Time.now.to_i,
+            },
+          ],
+        }
+      end
+
+      def logger
+        @logger ||= if defined?(Soba.logger)
+                      Soba.logger
+                    else
+                      SemanticLogger["SlackNotifier"]
+                    end
+      end
+    end
+  end
+end

data/lib/soba/services/status_manager.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'fileutils'
+require 'time'
+
+module Soba
+  module Services
+    class StatusManager
+      attr_reader :status_file
+
+      def initialize(status_file)
+        @status_file = status_file
+      end
+
+      def write(data)
+        dir = File.dirname(status_file)
+        FileUtils.mkdir_p(dir) unless File.directory?(dir)
+
+        # Atomic write using temp file
+        temp_file = "#{status_file}.tmp"
+        File.write(temp_file, JSON.pretty_generate(data))
+        File.rename(temp_file, status_file)
+      rescue StandardError => e
+        # Clean up temp file if something goes wrong
+        FileUtils.rm_f(temp_file) if defined?(temp_file)
+        raise e
+      end
+
+      def read
+        return nil unless File.exist?(status_file)
+
+        content = File.read(status_file)
+        return nil if content.empty?
+
+        JSON.parse(content, symbolize_names: true)
+      rescue JSON::ParserError, StandardError
+        nil
+      end
+
+      def update_current_issue(issue_number, phase)
+        data = read || {}
+        data[:current_issue] = {
+          number: issue_number,
+          phase: phase,
+          started_at: Time.now.iso8601,
+        }
+        write(data)
+      end
+
+      def update_last_processed
+        data = read || {}
+        if data[:current_issue]
+          data[:last_processed] = {
+            number: data[:current_issue][:number],
+            completed_at: Time.now.iso8601,
+          }
+          data.delete(:current_issue)
+        end
+        write(data)
+      end
+
+      def update_memory(memory_mb)
+        data = read || {}
+        data[:memory_mb] = memory_mb
+        write(data)
+      end
+
+      def clear
+        FileUtils.rm_f(status_file)
+      end
+    end
+  end
+end

data/lib/soba/services/test_process_manager.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require 'fileutils'
+require_relative 'pid_manager'
+
+module Soba
+  module Services
+    class TestProcessManager
+      TEST_PID_DIR = '/tmp/soba-test-pids'
+
+      def test_mode?
+        ENV['SOBA_TEST_MODE'] == 'true'
+      end
+
+      def generate_test_session_name(repository)
+        sanitized_repo = repository.gsub(/[\/._]/, '-')
+        "soba-test-#{sanitized_repo}-#{generate_test_id}"
+      end
+
+      def generate_test_id
+        "#{Process.pid}-#{SecureRandom.hex(4)}"
+      end
+
+      def test_pid_file_path(test_id)
+        "#{TEST_PID_DIR}/#{test_id}.pid"
+      end
+
+      def create_test_pid_manager(test_id)
+        pid_file = test_pid_file_path(test_id)
+        PidManager.new(pid_file)
+      end
+
+      def cleanup_test_processes(test_id, timeout: 10)
+        pid_manager = create_test_pid_manager(test_id)
+        cleaned_processes = []
+
+        pid = pid_manager.read
+        return { success: true, cleaned_processes: cleaned_processes } unless pid
+
+        if pid_manager.running?
+          begin
+            # Graceful termination
+            Process.kill('TERM', pid)
+
+            # Wait for graceful shutdown
+            wait_time = 0
+            while wait_time < timeout && pid_manager.running?
+              sleep(0.1)
+              wait_time += 0.1
+            end
+
+            # Force kill if still running
+            if pid_manager.running?
+              Process.kill('KILL', pid)
+              sleep(0.1) # Brief wait for force kill
+            end
+
+            cleaned_processes << pid
+          rescue Errno::ESRCH, Errno::EPERM
+            # Process already dead or no permission
+          end
+        end
+
+        # Clean up PID file
+        pid_manager.delete
+
+        { success: true, cleaned_processes: cleaned_processes }
+      rescue StandardError => e
+        { success: false, error: e.message, cleaned_processes: cleaned_processes }
+      end
+
+      def ensure_test_environment
+        if test_mode?
+          FileUtils.mkdir_p(TEST_PID_DIR)
+        end
+
+        { success: true, test_mode: test_mode? }
+      rescue StandardError => e
+        { success: false, error: e.message, test_mode: test_mode? }
+      end
+    end
+  end
+end