soba-cli 0.1.0

data/lib/soba/services/daemon_service.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'time'
+
+module Soba
+  module Services
+    class DaemonService
+      attr_reader :pid_manager, :log_file
+
+      def initialize(pid_manager:, log_file: nil)
+        @pid_manager = pid_manager
+        @log_file = log_file || File.expand_path('~/.soba/logs/daemon.log')
+      end
+
+      def already_running?
+        if pid_manager.running?
+          true
+        else
+          # Clean up stale PID file if exists
+          pid_manager.cleanup_if_stale
+          false
+        end
+      end
+
+      def daemonize!
+        # Fork and detach from terminal
+        Process.daemon(true, false)
+
+        # Write PID file
+        pid_manager.write
+
+        # Ensure log directory exists
+        ensure_log_directory
+
+        # Redirect stdout and stderr to log file
+        redirect_output_to_log
+      end
+
+      def setup_signal_handlers(&cleanup_block)
+        %w(TERM INT).each do |signal|
+          Signal.trap(signal) do
+            log "Received SIG#{signal}, shutting down gracefully..."
+            cleanup_block&.call
+            cleanup
+            exit(0)
+          end
+        end
+      end
+
+      def cleanup
+        log 'Cleaning up daemon...'
+        pid_manager.delete
+      end
+
+      def log(message)
+        ensure_log_directory
+        timestamp = Time.now.strftime('[%Y-%m-%d %H:%M:%S]')
+        File.open(log_file, 'a') do |f|
+          f.puts "#{timestamp} #{message}"
+          f.flush
+        end
+      rescue StandardError => e
+        warn "Failed to write to log: #{e.message}"
+      end
+
+      def ensure_log_directory
+        dir = File.dirname(log_file)
+        FileUtils.mkdir_p(dir) unless File.directory?(dir)
+      end
+
+      private
+
+      def redirect_output_to_log
+        log_io = File.open(log_file, 'a')
+        log_io.sync = true
+
+        $stdout.reopen(log_io)
+        $stderr.reopen(log_io)
+      end
+    end
+  end
+end

data/lib/soba/services/git_workspace_manager.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'fileutils'
+require_relative '../configuration'
+
+module Soba
+  module Services
+    class GitWorkspaceManager
+      class GitOperationError < StandardError; end
+
+      def initialize(configuration: nil)
+        @configuration = configuration || Soba::Configuration
+      end
+
+      def setup_workspace(issue_number)
+        worktree_path = worktree_path(issue_number)
+        branch_name = branch_name(issue_number)
+
+        # 既存のworktreeが存在する場合はスキップ
+        if Dir.exist?(worktree_path)
+          puts "Worktree already exists at #{worktree_path}, skipping setup"
+          return true
+        end
+
+        # worktreeディレクトリを作成
+        FileUtils.mkdir_p(@configuration.config.git.worktree_base_path)
+
+        # worktreeを作成
+        create_worktree(worktree_path, branch_name)
+
+        true
+      end
+
+      def cleanup_workspace(issue_number)
+        worktree_path = worktree_path(issue_number)
+
+        # worktreeが存在しない場合はスキップ
+        unless Dir.exist?(worktree_path)
+          puts "Worktree does not exist at #{worktree_path}, skipping cleanup"
+          return true
+        end
+
+        # worktreeを削除
+        remove_worktree(worktree_path)
+
+        true
+      end
+
+      def get_worktree_path(issue_number)
+        path = worktree_path(issue_number)
+        Dir.exist?(path) ? path : nil
+      end
+
+      def update_main_branch
+        # git fetch origin
+        _, stderr, status = Open3.capture3('git fetch origin')
+        unless status.success?
+          raise GitOperationError, "Failed to fetch from origin: #{stderr}"
+        end
+
+        # git checkout main
+        _, stderr, status = Open3.capture3('git checkout main')
+        unless status.success?
+          raise GitOperationError, "Failed to checkout main branch: #{stderr}"
+        end
+
+        # git pull origin main
+        _, stderr, status = Open3.capture3('git pull origin main')
+        unless status.success?
+          raise GitOperationError, "Failed to pull latest changes from main: #{stderr}"
+        end
+      end
+
+      private
+
+      def worktree_path(issue_number)
+        "#{@configuration.config.git.worktree_base_path}/issue-#{issue_number}"
+      end
+
+      def branch_name(issue_number)
+        "soba/#{issue_number}"
+      end
+
+      def create_worktree(worktree_path, branch_name)
+        command = "git worktree add -b #{branch_name} #{worktree_path} origin/main"
+        _, stderr, status = Open3.capture3(command)
+        unless status.success?
+          raise GitOperationError, "Failed to create worktree: #{stderr}"
+        end
+      end
+
+      def remove_worktree(worktree_path)
+        command = "git worktree remove #{worktree_path} --force"
+        _, stderr, status = Open3.capture3(command)
+        unless status.success?
+          raise GitOperationError, "Failed to remove worktree: #{stderr}"
+        end
+      end
+    end
+  end
+end

data/lib/soba/services/issue_monitor.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Soba
+  module Services
+    class IssueMonitor
+      def initialize(github_client: nil)
+        @github_client = github_client || Infrastructure::GitHubClient.new
+      end
+
+      def monitor(repository:, interval: 60)
+        Soba.logger.info("Starting issue monitor for #{repository}")
+
+        loop do
+          check_issues(repository)
+          sleep(interval)
+        end
+      end
+
+      private
+
+      def check_issues(repository)
+        issues = @github_client.issues(repository)
+        Soba.logger.debug("Found #{issues.count} open issues")
+      rescue => e
+        Soba.logger.error("Failed to fetch issues: #{e.message}")
+      end
+    end
+  end
+end

data/lib/soba/services/issue_processor.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+require 'ostruct'
+require_relative '../configuration'
+require_relative '../infrastructure/github_client'
+require_relative '../infrastructure/tmux_client'
+require_relative '../domain/phase_strategy'
+require_relative 'workflow_executor'
+require_relative 'tmux_session_manager'
+require_relative 'git_workspace_manager'
+
+module Soba
+  module Services
+    class IssueProcessingError < StandardError; end
+
+    class IssueProcessor
+      attr_reader :github_client, :workflow_executor, :phase_strategy, :config
+
+      def initialize(github_client: nil, workflow_executor: nil, phase_strategy: nil, config: nil)
+        @github_client = github_client || Infrastructure::GitHubClient.new
+        @config = config || Configuration
+        @workflow_executor = workflow_executor || WorkflowExecutor.new(
+          tmux_session_manager: TmuxSessionManager.new(
+            tmux_client: Infrastructure::TmuxClient.new
+          ),
+          git_workspace_manager: GitWorkspaceManager.new(configuration: @config)
+        )
+        @phase_strategy = phase_strategy || Domain::PhaseStrategy.new
+      end
+
+      def run(issue_number, use_tmux: true)
+        # Fetch issue details from GitHub
+        repository = get_repository_from_config
+        issue = @github_client.issue(repository, issue_number)
+
+        # Convert issue to expected format
+        issue_hash = {
+          number: issue.number,
+          title: issue.title,
+          labels: issue.labels.map { |l| l.name || l[:name] },
+        }
+
+        # Process with the specified tmux mode
+        original_use_tmux = @config.config.workflow.use_tmux
+        begin
+          # Temporarily override the config value
+          @config.config.workflow.use_tmux = use_tmux
+          process(issue_hash)
+        ensure
+          # Restore original config value
+          @config.config.workflow.use_tmux = original_use_tmux
+        end
+      end
+
+      def process(issue)
+        phase = phase_strategy.determine_phase(issue[:labels])
+
+        return skipped_result('No phase determined for issue') unless phase
+
+        current_label = current_label_for_phase(phase)
+        next_label = phase_strategy.next_label(phase)
+
+        begin
+          repository = get_repository_from_config
+          github_client.update_issue_labels(
+            repository,
+            issue[:number],
+            from: current_label,
+            to: next_label
+          )
+        rescue StandardError => e
+          raise IssueProcessingError, "Failed to update labels: #{e.message}"
+        end
+
+        phase_config = get_phase_config(phase)
+
+        if phase_config&.command
+          puts "Processing phase: #{phase} with command: #{phase_config.command}"
+          puts "  Phase name: #{phase_config.name || 'not set'}"
+
+          actual_config = config.respond_to?(:config) ? config.config : config
+          use_tmux = actual_config.workflow.use_tmux
+          setup_workspace = actual_config.git.setup_workspace
+
+          execution_result = workflow_executor.execute(
+            phase: phase_config,
+            issue_number: issue[:number],
+            use_tmux: use_tmux,
+            setup_workspace: setup_workspace,
+            issue_title: issue[:title],
+            phase_name: phase.to_s
+          )
+
+          result = {
+            success: execution_result[:success],
+            phase: phase,
+            issue_number: issue[:number],
+            label_updated: true,
+            output: execution_result[:output],
+            error: execution_result[:error],
+          }
+
+          # Add tmux-specific fields if present
+          result[:mode] = execution_result[:mode] if execution_result[:mode]
+          result[:session_name] = execution_result[:session_name] if execution_result[:session_name]
+          result[:window_name] = execution_result[:window_name] if execution_result[:window_name]
+          result[:pane_id] = execution_result[:pane_id] if execution_result[:pane_id]
+          result[:tmux_info] = execution_result[:tmux_info] if execution_result[:tmux_info]
+
+          result
+        else
+          {
+            success: true,
+            phase: phase,
+            issue_number: issue[:number],
+            label_updated: true,
+            workflow_skipped: true,
+            reason: 'Phase configuration not defined',
+          }
+        end
+      end
+
+      private
+
+      def get_repository_from_config
+        actual_config = @config.respond_to?(:config) ? @config.config : @config
+        actual_config.github.repository
+      end
+
+      def skipped_result(reason)
+        {
+          success: true,
+          skipped: true,
+          reason: reason,
+        }
+      end
+
+      def current_label_for_phase(phase)
+        phase_strategy.current_label_for_phase(phase)
+      end
+
+      def get_phase_config(phase)
+        case phase
+        when :plan, :queued_to_planning
+          # config is the Configuration module, get the actual config object
+          actual_config = config.respond_to?(:config) ? config.config : config
+          plan_config = actual_config.phase.plan
+
+          # Access values through @_values instead of @values
+          values = plan_config.instance_variable_get(:@_values)
+
+          if values
+            OpenStruct.new(
+              name: 'plan',
+              command: values[:command],
+              options: values[:options],
+              parameter: values[:parameter]
+            )
+          else
+            nil
+          end
+        when :implement
+          actual_config = config.respond_to?(:config) ? config.config : config
+          impl_config = actual_config.phase.implement
+          values = impl_config.instance_variable_get(:@_values)
+
+          if values
+            OpenStruct.new(
+              name: 'implement',
+              command: values[:command],
+              options: values[:options],
+              parameter: values[:parameter]
+            )
+          else
+            nil
+          end
+        when :review
+          actual_config = config.respond_to?(:config) ? config.config : config
+          review_config = actual_config.phase.review
+          values = review_config.instance_variable_get(:@_values)
+
+          if values
+            OpenStruct.new(
+              name: 'review',
+              command: values[:command],
+              options: values[:options],
+              parameter: values[:parameter]
+            )
+          else
+            nil
+          end
+        when :revise
+          actual_config = config.respond_to?(:config) ? config.config : config
+          revise_config = actual_config.phase.revise
+          values = revise_config.instance_variable_get(:@_values)
+
+          if values
+            OpenStruct.new(
+              name: 'revise',
+              command: values[:command],
+              options: values[:options],
+              parameter: values[:parameter]
+            )
+          else
+            nil
+          end
+        else
+          nil
+        end
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/soba/services/issue_watcher.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require "concurrent-ruby"
+require "time"
+
+module Soba
+  module Services
+    class IssueWatcher
+      include SemanticLogger::Loggable
+
+      MIN_INTERVAL = 10
+
+      def initialize(client: nil, repository: nil, interval: nil)
+        @github_client = client || Infrastructure::GitHubClient.new
+        @repository = repository
+        @interval = interval
+        @running = Concurrent::AtomicBoolean.new(false)
+        @mutex = Mutex.new
+        @signal_received = false
+      end
+
+      def start(repository:, interval: 20)
+        validate_interval!(interval)
+
+        logger.info "Starting issue watcher", repository: repository, interval: interval
+        @running.make_true
+        @repository = repository
+        @interval = interval
+
+        setup_signal_handlers
+        display_header
+
+        execution_count = run_monitoring_loop
+
+        # Show graceful shutdown message
+        if @signal_received
+          puts "\n✅ Issue watcher stopped gracefully (#{execution_count} executions)"
+        else
+          puts "\n✅ Issue watcher stopped successfully (#{execution_count} executions)"
+          logger.info "Issue watcher stopped", executions: execution_count
+        end
+      ensure
+        @running.make_false
+      end
+
+      def stop
+        @running.make_false
+      end
+
+      def running?
+        @running.value
+      end
+
+      def fetch_issues(state: "open")
+        @github_client.issues(@repository, state: state)
+      end
+
+      private
+
+      def validate_interval!(interval)
+        if interval < MIN_INTERVAL
+          raise ArgumentError, "Interval must be at least #{MIN_INTERVAL} seconds to avoid rate limiting"
+        end
+      end
+
+      def setup_signal_handlers
+        %w(INT TERM).each do |signal|
+          Signal.trap(signal) do
+            @signal_received = true
+            puts "\n\n🛑 Received #{signal} signal, shutting down gracefully..."
+            @running.make_false
+          end
+        end
+      end
+
+      def run_monitoring_loop
+        execution_count = 0
+
+        while running?
+          @mutex.synchronize do
+            fetch_and_display_issues
+            execution_count += 1
+          end
+
+          break unless running?
+          sleep(@interval)
+        end
+
+        execution_count
+      rescue => e
+        # Skip logging if interrupted by signal
+        unless @signal_received
+          logger.error "Unexpected error in monitoring loop", error: e.message
+          raise
+        end
+        execution_count
+      end
+
+      def fetch_and_display_issues
+        issues = @github_client.issues(@repository, state: "open")
+
+        display_issues(issues)
+        log_execution_summary(issues)
+      rescue Soba::Infrastructure::NetworkError => e
+        logger.error "Failed to fetch issues", error: e.message, repository: @repository
+        puts "\n⚠️  Network error: #{e.message}"
+      rescue Soba::Infrastructure::RateLimitExceeded => e
+        logger.warn "Rate limit exceeded", error: e.message
+        puts "\n⚠️  Rate limit exceeded. Waiting before retry..."
+        handle_rate_limit
+      rescue => e
+        logger.error "Unexpected error fetching issues", error: e.message, class: e.class.name
+        puts "\n❌ Error: #{e.message}"
+      end
+
+      def display_header
+        puts "\n" + "=" * 80
+        puts "📋 Issue Watcher Started"
+        puts "Repository: #{@repository}"
+        puts "Interval: #{@interval} seconds"
+        puts "Press Ctrl+C to stop"
+        puts "=" * 80
+        puts
+      end
+
+      def display_issues(issues)
+        timestamp = Time.now.strftime("%Y-%m-%d %H:%M:%S")
+        puts "\n[#{timestamp}] Found #{issues.count} open issues"
+
+        if issues.empty?
+          puts "  No open issues found."
+          return
+        end
+
+        puts "\n  %-6s | %-50s | %-20s | %s" % ["#", "Title", "Labels", "Updated"]
+        puts "  #{"-" * 90}"
+
+        issues.each do |issue|
+          display_issue_row(issue)
+        end
+        puts
+      end
+
+      def display_issue_row(issue)
+        number = "##{issue.number}"
+        title = truncate(issue.title, 50)
+        labels = format_labels(issue.labels)
+        updated = format_time(issue.updated_at)
+
+        puts "  %-6s | %-50s | %-20s | %s" % [number, title, labels, updated]
+      end
+
+      def format_labels(labels)
+        return "-" if labels.empty?
+
+        label_names = labels.map { |label| label[:name] }
+        truncate(label_names.join(", "), 20)
+      end
+
+      def format_time(time)
+        return "-" unless time
+
+        diff = Time.now - time
+        case diff
+        when 0...3600
+          "#{(diff / 60).to_i} mins ago"
+        when 3600...86400
+          "#{(diff / 3600).to_i} hours ago"
+        else
+          "#{(diff / 86400).to_i} days ago"
+        end
+      end
+
+      def truncate(text, max_length)
+        return text if text.length <= max_length
+
+        "#{text[0...max_length - 3]}..."
+      end
+
+      def log_execution_summary(issues)
+        logger.debug "Issue fetch completed",
+                     repository: @repository,
+                     issue_count: issues.count,
+                     timestamp: Time.now.iso8601
+      end
+
+      def handle_rate_limit
+        # Wait for 1 minute before retrying
+        sleep(60) if running?
+      end
+    end
+  end
+end

data/lib/soba/services/pid_manager.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'timeout'
+
+module Soba
+  module Services
+    class PidManager
+      attr_reader :pid_file
+
+      def initialize(pid_file)
+        @pid_file = pid_file
+      end
+
+      def write(pid = Process.pid)
+        ensure_directory_exists
+        File.open(pid_file, 'w') do |f|
+          f.flock(File::LOCK_EX)
+          f.write(pid.to_s)
+          f.flush
+        end
+      end
+
+      def read
+        return nil unless File.exist?(pid_file)
+
+        content = File.read(pid_file).strip
+        return nil if content.empty?
+
+        pid = content.to_i
+        return nil if pid <= 0
+
+        pid
+      rescue StandardError
+        nil
+      end
+
+      def delete
+        return false unless File.exist?(pid_file)
+
+        File.delete(pid_file)
+        true
+      rescue StandardError
+        false
+      end
+
+      def running?
+        pid = read
+        return false unless pid
+
+        # Check if process exists
+        Process.kill(0, pid)
+        true
+      rescue Errno::ESRCH, Errno::EPERM
+        false
+      end
+
+      def cleanup_if_stale
+        return false unless File.exist?(pid_file)
+
+        if running?
+          false
+        else
+          delete
+          true
+        end
+      end
+
+      def lock(timeout: 5)
+        ensure_directory_exists
+        Timeout.timeout(timeout) do
+          File.open(pid_file, File::CREAT | File::WRONLY) do |f|
+            f.flock(File::LOCK_EX)
+            yield if block_given?
+          end
+        end
+      end
+
+      private
+
+      def ensure_directory_exists
+        dir = File.dirname(pid_file)
+        FileUtils.mkdir_p(dir) unless File.directory?(dir)
+      end
+    end
+  end
+end