soba-cli 0.1.0

data/lib/soba/commands/status.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require 'time'
+require 'json'
+require_relative '../services/pid_manager'
+require_relative '../services/status_manager'
+require_relative '../services/process_info'
+
+module Soba
+  module Commands
+    class Status
+      def execute(_global_options = {}, options = {}, _args = [])
+        # Allow test environment to override paths
+        pid_file = ENV['SOBA_TEST_PID_FILE'] || File.expand_path('~/.soba/soba.pid')
+        log_file = ENV['SOBA_TEST_LOG_FILE'] || File.expand_path('~/.soba/logs/daemon.log')
+        status_file = ENV['SOBA_TEST_STATUS_FILE'] || File.expand_path('~/.soba/status.json')
+
+        pid_manager = Soba::Services::PidManager.new(pid_file)
+        status_manager = Soba::Services::StatusManager.new(status_file)
+        pid = pid_manager.read
+
+        # JSON出力の場合
+        if options[:json]
+          output_json(pid_manager, status_manager, log_file, pid, options)
+          return 0
+        end
+
+        # 通常のテキスト出力
+        output_text(pid_manager, status_manager, log_file, pid, options)
+      end
+
+      private
+
+      def output_text(pid_manager, status_manager, log_file, pid, options)
+        puts "=" * 50
+        puts "Soba Daemon Status"
+        puts "=" * 50
+
+        status_data = status_manager.read
+
+        if pid_manager.running?
+          puts "Daemon Status: Running"
+          puts "PID: #{pid}"
+
+          # Try to get process start time and memory usage
+          begin
+            # Get file creation time as approximation
+            pid_file_path = File.expand_path('~/.soba/soba.pid')
+            if File.exist?(pid_file_path)
+              start_time = File.ctime(pid_file_path)
+              uptime = Time.now - start_time
+              puts "Started: #{start_time.strftime('%Y-%m-%d %H:%M:%S')}"
+              puts "Uptime: #{format_uptime(uptime)}"
+            end
+
+            # Get memory usage
+            process_info = Soba::Services::ProcessInfo.new(pid)
+            memory_mb = process_info.memory_usage_mb
+            memory_mb ||= status_data[:memory_mb] if status_data
+            puts "Memory Usage: #{memory_mb} MB" if memory_mb
+          rescue StandardError
+            # Ignore errors getting process info
+          end
+
+          # Display current Issue and last processed
+          if status_data
+            if status_data[:current_issue]
+              issue = status_data[:current_issue]
+              puts "\nCurrent Issue: ##{issue[:number]} (#{issue[:phase]})"
+            end
+
+            if status_data[:last_processed]
+              last = status_data[:last_processed]
+              puts "Last Processed: ##{last[:number]} (completed at #{last[:completed_at]})"
+            end
+          end
+        elsif pid
+          puts "Daemon Status: Not running"
+          puts "Stale PID file found (PID: #{pid})"
+          puts "Run 'soba start' to start the daemon"
+          return 1
+        else
+          puts "No daemon process is running"
+          puts "Run 'soba start' to start the daemon"
+          return 0
+        end
+
+        puts ""
+        puts "Recent Log Output:"
+        puts "-" * 50
+
+        if File.exist?(log_file)
+          if File.size(log_file) > 0
+            # Get specified number of log lines
+            num_lines = options[:log] || 10
+            log_lines = File.readlines(log_file).last(num_lines)
+            log_lines.each { |line| puts line.chomp }
+          else
+            puts "Log file is empty"
+          end
+        else
+          puts "No log file found at #{log_file}"
+        end
+
+        puts "=" * 50
+
+        0
+      end
+
+      def output_json(pid_manager, status_manager, log_file, pid, options)
+        status_data = status_manager.read || {}
+        result = {}
+
+        if pid_manager.running?
+          pid_file_path = File.expand_path('~/.soba/soba.pid')
+          daemon_info = {
+            status: 'running',
+            pid: pid,
+          }
+
+          # Add start time and uptime
+          if File.exist?(pid_file_path)
+            start_time = File.ctime(pid_file_path)
+            uptime = Time.now - start_time
+            daemon_info[:started_at] = start_time.iso8601
+            daemon_info[:uptime_seconds] = uptime.to_i
+          end
+
+          # Add memory usage
+          process_info = Soba::Services::ProcessInfo.new(pid)
+          memory_mb = process_info.memory_usage_mb || status_data[:memory_mb]
+          daemon_info[:memory_mb] = memory_mb if memory_mb
+
+          result[:daemon] = daemon_info
+        else
+          result[:daemon] = { status: 'not_running' }
+        end
+
+        # Add current Issue info
+        if status_data[:current_issue]
+          result[:current_issue] = status_data[:current_issue]
+        end
+
+        # Add last processed info
+        if status_data[:last_processed]
+          result[:last_processed] = status_data[:last_processed]
+        end
+
+        # Add logs
+        if File.exist?(log_file) && File.size(log_file) > 0
+          num_lines = options[:log] || 10
+          log_lines = File.readlines(log_file).last(num_lines)
+          result[:logs] = log_lines.map(&:chomp)
+        else
+          result[:logs] = []
+        end
+
+        puts JSON.pretty_generate(result)
+      end
+
+      def format_uptime(seconds)
+        days = (seconds / 86400).to_i
+        hours = ((seconds % 86400) / 3600).to_i
+        minutes = ((seconds % 3600) / 60).to_i
+
+        parts = []
+        parts << "#{days}d" if days > 0
+        parts << "#{hours}h" if hours > 0
+        parts << "#{minutes}m" if minutes > 0 || parts.empty?
+
+        parts.join(' ')
+      end
+    end
+  end
+end

data/lib/soba/commands/stop.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require_relative '../services/pid_manager'
+require_relative '../infrastructure/tmux_client'
+
+module Soba
+  module Commands
+    class Stop
+      def execute(_global_options = {}, options = {}, _args = [])
+        # Allow test environment to override PID file path
+        pid_file = ENV['SOBA_TEST_PID_FILE'] || File.expand_path('~/.soba/soba.pid')
+        pid_manager = Soba::Services::PidManager.new(pid_file)
+
+        pid = pid_manager.read
+
+        unless pid
+          puts "No daemon process is running"
+          return 1
+        end
+
+        unless pid_manager.running?
+          Soba.logger.info "Daemon was not running (stale PID file cleaned up)"
+          pid_manager.delete
+          return 0
+        end
+
+        puts "Stopping daemon (PID: #{pid})..."
+
+        # Create PID-based stopping file for graceful shutdown
+        # This ensures each process has its own stopping file to avoid conflicts
+        stopping_file = File.expand_path("~/.soba/stopping.#{pid}")
+        FileUtils.mkdir_p(File.dirname(stopping_file))
+        FileUtils.touch(stopping_file)
+
+        begin
+          # Check if force option is specified
+          if options[:force]
+            # Force kill immediately
+            Soba.logger.warn "Forcefully terminating daemon (PID: #{pid})"
+            Process.kill('KILL', pid)
+            sleep 1
+            cleanup_tmux_sessions
+            pid_manager.delete
+            FileUtils.rm_f(stopping_file)
+            Soba.logger.warn "Daemon forcefully terminated"
+            return 0
+          end
+
+          # Send SIGTERM for graceful shutdown
+          Process.kill('TERM', pid)
+          Soba.logger.info "Sent SIGTERM signal, waiting for daemon to terminate"
+
+          # Use custom timeout if specified
+          timeout_value = options[:timeout] || 30
+
+          # Wait for process to terminate gracefully
+          if wait_for_termination(pid, timeout: timeout_value)
+            Soba.logger.info "Daemon stopped successfully"
+            cleanup_tmux_sessions
+            pid_manager.delete
+            FileUtils.rm_f(stopping_file)
+            0
+          else
+            # Force kill if not terminated
+            Soba.logger.warn "Daemon did not stop gracefully, forcefully terminating"
+            Process.kill('KILL', pid)
+            sleep 1
+            cleanup_tmux_sessions
+            pid_manager.delete
+            FileUtils.rm_f(stopping_file)
+            Soba.logger.warn "Daemon forcefully terminated"
+            0
+          end
+        rescue Errno::ESRCH
+          # Process doesn't exist
+          Soba.logger.info "Process not found (already terminated)"
+          pid_manager.delete
+          FileUtils.rm_f(stopping_file)
+          0
+        rescue Errno::EPERM
+          # Permission denied
+          puts "Permission denied: unable to stop daemon (PID: #{pid})"
+          puts "You may need to run this command with appropriate permissions"
+          FileUtils.rm_f(stopping_file)
+          1
+        rescue StandardError => e
+          Soba.logger.error "Error stopping daemon: #{e.message}"
+          FileUtils.rm_f(stopping_file)
+          1
+        end
+      end
+
+      private
+
+      def wait_for_termination(pid, timeout: 30)
+        deadline = Time.now + timeout
+
+        while Time.now < deadline
+          begin
+            # Check if process still exists
+            Process.kill(0, pid)
+            sleep 0.5
+          rescue Errno::ESRCH
+            # Process no longer exists
+            return true
+          end
+        end
+
+        false
+      end
+
+      def cleanup_tmux_sessions
+        tmux_client = Soba::Infrastructure::TmuxClient.new
+        repository = Soba::Configuration.config.github&.repository
+
+        if repository
+          # Kill only the current process's session
+          session_name = "soba-#{repository.gsub(/[\/._]/, '-')}-#{Process.pid}"
+          if tmux_client.session_exists?(session_name)
+            Soba.logger.info "Cleaning up tmux session"
+            if tmux_client.kill_session(session_name)
+              Soba.logger.info "Killed tmux session: #{session_name}"
+            else
+              Soba.logger.warn "Failed to kill tmux session: #{session_name}"
+            end
+          end
+        else
+          # If no repository configured, try to clean up sessions with current PID
+          sessions = tmux_client.list_soba_sessions.select { |s| s.end_with?("-#{Process.pid}") }
+          unless sessions.empty?
+            Soba.logger.info "Cleaning up tmux sessions"
+            sessions.each do |session|
+              if tmux_client.kill_session(session)
+                Soba.logger.info "Killed tmux session: #{session}"
+              else
+                Soba.logger.warn "Failed to kill tmux session: #{session}"
+              end
+            end
+          end
+        end
+      rescue StandardError => e
+        Soba.logger.warn "Failed to cleanup tmux sessions: #{e.message}"
+      end
+    end
+  end
+end

data/lib/soba/config_loader.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'configuration'
+
+module Soba
+  module ConfigLoader
+    class << self
+      def load(path: nil)
+        Configuration.load!(path: path)
+      rescue ConfigurationError => e
+        handle_config_error(e)
+      end
+
+      def reload
+        Configuration.reset_config
+        load
+      end
+
+      def config
+        @config ||= load
+      end
+
+      private
+
+      def handle_config_error(error)
+        Soba.logger.error "Configuration Error: #{error.message}"
+        Soba.logger.error "Please check your .soba/config.yml file."
+        exit 1
+      end
+    end
+  end
+end

data/lib/soba/configuration.rb

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object/blank'
+require 'dry-configurable'
+require 'yaml'
+require 'pathname'
+
+module Soba
+  class Configuration
+    extend Dry::Configurable
+
+    setting :github do
+      setting :token, default: ENV.fetch('GITHUB_TOKEN', nil)
+      setting :repository
+    end
+
+    setting :workflow do
+      setting :interval, default: 20
+      setting :use_tmux, default: true
+      setting :auto_merge_enabled, default: true
+      setting :closed_issue_cleanup_enabled, default: true
+      setting :closed_issue_cleanup_interval, default: 300 # 5 minutes in seconds
+      setting :tmux_command_delay, default: 3 # delay in seconds before sending commands to tmux
+    end
+
+    setting :slack do
+      setting :webhook_url
+      setting :notifications_enabled, default: false
+    end
+
+    setting :git do
+      setting :worktree_base_path, default: '.git/soba/worktrees'
+      setting :setup_workspace, default: true
+    end
+
+    setting :phase do
+      setting :plan do
+        setting :command
+        setting :options, default: []
+        setting :parameter
+      end
+      setting :implement do
+        setting :command
+        setting :options, default: []
+        setting :parameter
+      end
+      setting :review do
+        setting :command
+        setting :options, default: []
+        setting :parameter
+      end
+      setting :revise do
+        setting :command
+        setting :options, default: []
+        setting :parameter
+      end
+    end
+
+    class << self
+      def reset_config
+        @config = nil
+        configure do |c|
+          c.github.token = ENV.fetch('GITHUB_TOKEN', nil)
+          c.github.repository = nil
+          c.workflow.interval = 20
+          c.workflow.use_tmux = true
+          c.workflow.auto_merge_enabled = true
+          c.workflow.closed_issue_cleanup_enabled = true
+          c.workflow.closed_issue_cleanup_interval = 300
+          c.workflow.tmux_command_delay = 3
+          c.slack.webhook_url = nil
+          c.slack.notifications_enabled = false
+          c.git.worktree_base_path = '.git/soba/worktrees'
+          c.git.setup_workspace = true
+          c.phase.plan.command = nil
+          c.phase.plan.options = []
+          c.phase.plan.parameter = nil
+          c.phase.implement.command = nil
+          c.phase.implement.options = []
+          c.phase.implement.parameter = nil
+          c.phase.review.command = nil
+          c.phase.review.options = []
+          c.phase.review.parameter = nil
+          c.phase.revise.command = nil
+          c.phase.revise.options = []
+          c.phase.revise.parameter = nil
+        end
+      end
+
+      def load!(path: nil)
+        config_path = find_config_file(path)
+
+        if config_path && File.exist?(config_path)
+          load_from_file(config_path)
+        else
+          create_default_config(config_path || default_config_path)
+        end
+
+        validate!
+        config
+      end
+
+      private
+
+      def find_config_file(path)
+        return Pathname.new(path) if path
+
+        # プロジェクトルートの.soba/config.ymlを探す
+        project_root = find_project_root
+        return nil unless project_root
+
+        project_root.join('.soba', 'config.yml')
+      end
+
+      def find_project_root
+        current = Pathname.pwd
+
+        until current.root?
+          return current if current.join('.git').exist?
+          current = current.parent
+        end
+
+        Pathname.pwd
+      end
+
+      def default_config_path
+        find_project_root.join('.soba', 'config.yml')
+      end
+
+      def load_from_file(path)
+        content = File.read(path)
+        # 環境変数を展開
+        expanded_content = content.gsub(/\$\{([^}]+)\}/) do |match|
+          var_name = Regexp.last_match(1)
+          ENV[var_name] || match
+        end
+        data = YAML.safe_load(expanded_content, permitted_classes: [Symbol])
+
+        reset_config
+        configure do |c|
+          if data['github']
+            c.github.token = data.dig('github', 'token') || ENV.fetch('GITHUB_TOKEN', nil)
+            c.github.repository = data.dig('github', 'repository')
+          end
+
+          if data['workflow']
+            c.workflow.interval = data.dig('workflow', 'interval') || 20
+            c.workflow.use_tmux = data.dig('workflow', 'use_tmux') != false # default true
+            c.workflow.auto_merge_enabled = data.dig('workflow', 'auto_merge_enabled') != false # default true
+            cleanup_enabled = data.dig('workflow', 'closed_issue_cleanup_enabled')
+            c.workflow.closed_issue_cleanup_enabled = cleanup_enabled != false # default true
+            c.workflow.closed_issue_cleanup_interval = data.dig('workflow', 'closed_issue_cleanup_interval') || 300
+            c.workflow.tmux_command_delay = data.dig('workflow', 'tmux_command_delay') || 3
+          end
+
+          if data['slack']
+            c.slack.webhook_url = data.dig('slack', 'webhook_url')
+            c.slack.notifications_enabled = data.dig('slack', 'notifications_enabled') || false
+          end
+
+          if data['git']
+            c.git.worktree_base_path = data.dig('git', 'worktree_base_path') || '.git/soba/worktrees'
+            c.git.setup_workspace = data.dig('git', 'setup_workspace') != false  # default true
+          end
+
+          if data['phase']
+            if data['phase']['plan']
+              c.phase.plan.command = data.dig('phase', 'plan', 'command')
+              c.phase.plan.options = data.dig('phase', 'plan', 'options') || []
+              c.phase.plan.parameter = data.dig('phase', 'plan', 'parameter')
+            end
+            if data['phase']['implement']
+              c.phase.implement.command = data.dig('phase', 'implement', 'command')
+              c.phase.implement.options = data.dig('phase', 'implement', 'options') || []
+              c.phase.implement.parameter = data.dig('phase', 'implement', 'parameter')
+            end
+            if data['phase']['review']
+              c.phase.review.command = data.dig('phase', 'review', 'command')
+              c.phase.review.options = data.dig('phase', 'review', 'options') || []
+              c.phase.review.parameter = data.dig('phase', 'review', 'parameter')
+            end
+            if data['phase']['revise']
+              c.phase.revise.command = data.dig('phase', 'revise', 'command')
+              c.phase.revise.options = data.dig('phase', 'revise', 'options') || []
+              c.phase.revise.parameter = data.dig('phase', 'revise', 'parameter')
+            end
+          end
+        end
+      end
+
+      def create_default_config(path)
+        path.dirname.mkpath
+
+        default_content = <<~YAML
+          # soba CLI configuration
+          github:
+            # GitHub Personal Access Token
+            # Can use environment variable: ${GITHUB_TOKEN}
+            token: ${GITHUB_TOKEN}
+
+            # Target repository (format: owner/repo)
+            repository: # e.g., douhashi/soba
+
+          workflow:
+            # Issue polling interval in seconds
+            interval: 20
+            # Use tmux for Claude execution (default: true)
+            use_tmux: true
+            # Enable automatic merging of PRs with soba:lgtm label (default: true)
+            auto_merge_enabled: true
+            # Enable automatic cleanup of tmux windows for closed issues (default: true)
+            closed_issue_cleanup_enabled: true
+            # Cleanup interval in seconds (default: 300 = 5 minutes)
+            closed_issue_cleanup_interval: 300
+            # Delay in seconds before sending commands to new tmux panes/windows (default: 3)
+            tmux_command_delay: 3
+
+          slack:
+            # Slack webhook URL for sending notifications
+            # Can use environment variable: ${SLACK_WEBHOOK_URL}
+            webhook_url: ${SLACK_WEBHOOK_URL}
+            # Enable Slack notifications for phase starts (default: false)
+            notifications_enabled: false
+
+          git:
+            # Base path for git worktrees
+            worktree_base_path: .git/soba/worktrees
+            # Automatically setup workspace on phase start
+            setup_workspace: true
+
+          # Phase command configuration (optional)
+          # phase:
+          #   plan:
+          #     command: claude
+          #     options:
+          #       - --dangerously-skip-permissions
+          #     parameter: '/osoba:plan {{issue-number}}'
+          #   implement:
+          #     command: claude
+          #     options:
+          #       - --dangerously-skip-permissions
+          #     parameter: '/osoba:implement {{issue-number}}'
+          #   review:
+          #     command: claude
+          #     options:
+          #       - --dangerously-skip-permissions
+          #     parameter: '/soba:review {{issue-number}}'
+        YAML
+
+        File.write(path, default_content)
+        puts "Created default configuration at: #{path}"
+        puts "Please edit the configuration file and set your GitHub repository."
+      end
+
+      def validate!
+        errors = []
+
+        errors << "GitHub token is not set" if config.github.token.blank?
+        errors << "GitHub repository is not set" if config.github.repository.blank?
+        errors << "Workflow interval must be positive" if config.workflow.interval <= 0
+
+        unless errors.empty?
+          raise ConfigurationError, "Configuration errors:\n  #{errors.join("\n  ")}"
+        end
+      end
+    end
+  end
+end

data/lib/soba/container.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "dry-container"
+require "dry-auto_inject"
+
+module Soba
+  class Container
+    extend Dry::Container::Mixin
+
+    namespace :github do
+      register(:client) do
+        require_relative "infrastructure/github_client"
+        Infrastructure::GitHubClient.new
+      end
+    end
+
+    namespace :tmux do
+      register(:client) do
+        require_relative "infrastructure/tmux_client"
+        Infrastructure::TmuxClient.new
+      end
+    end
+
+    namespace :services do
+      register(:issue_monitor) do
+        require_relative "services/issue_monitor"
+        Services::IssueMonitor.new
+      end
+
+      register(:issue_watcher) do
+        require_relative "services/issue_watcher"
+        Services::IssueWatcher.new(github_client: Container["github.client"])
+      end
+
+      register(:tmux_session_manager) do
+        require_relative "services/tmux_session_manager"
+        Services::TmuxSessionManager.new(tmux_client: Container["tmux.client"])
+      end
+
+      register(:workflow_executor) do
+        require_relative "workflow_executor"
+        Services::WorkflowExecutor.new(tmux_session_manager: Container["services.tmux_session_manager"])
+      end
+    end
+  end
+
+  Import = Dry::AutoInject(Container)
+end