aidp 0.13.0 → 0.14.0

data/lib/aidp/daemon/process_manager.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Aidp
+  module Daemon
+    # Manages daemon process lifecycle: start, stop, status, attach
+    # Handles PID file management and process communication
+    class ProcessManager
+      DAEMON_DIR = ".aidp/daemon"
+      PID_FILE = "#{DAEMON_DIR}/aidp.pid"
+      SOCKET_FILE = "#{DAEMON_DIR}/aidp.sock"
+      LOG_FILE = "#{DAEMON_DIR}/daemon.log"
+
+      def initialize(project_dir = Dir.pwd)
+        @project_dir = project_dir
+        @pid_file_path = File.join(@project_dir, PID_FILE)
+        @socket_path = File.join(@project_dir, SOCKET_FILE)
+        @log_path = File.join(@project_dir, LOG_FILE)
+        ensure_daemon_dir
+      end
+
+      # Check if daemon is running
+      def running?
+        return false unless File.exist?(@pid_file_path)
+
+        pid = read_pid
+        return false unless pid
+
+        Process.kill(0, pid)
+        true
+      rescue Errno::ESRCH
+        # Process doesn't exist
+        cleanup_stale_files
+        false
+      rescue Errno::EPERM
+        # Process exists but we don't have permission
+        true
+      end
+
+      # Get daemon PID
+      def pid
+        return nil unless running?
+        read_pid
+      end
+
+      # Get daemon status summary
+      def status
+        if running?
+          {
+            running: true,
+            pid: pid,
+            socket: File.exist?(@socket_path),
+            log_file: @log_path
+          }
+        else
+          {
+            running: false,
+            pid: nil,
+            socket: false,
+            log_file: @log_path
+          }
+        end
+      end
+
+      # Write PID file for daemon
+      def write_pid(daemon_pid = Process.pid)
+        File.write(@pid_file_path, daemon_pid.to_s)
+      end
+
+      # Remove PID file
+      def remove_pid
+        File.delete(@pid_file_path) if File.exist?(@pid_file_path)
+      end
+
+      # Stop daemon gracefully
+      def stop(timeout: 30)
+        return {success: false, message: "Daemon not running"} unless running?
+
+        daemon_pid = pid
+        Process.kill("TERM", daemon_pid)
+
+        # Wait for process to exit
+        timeout.times do
+          sleep 1
+          unless process_exists?(daemon_pid)
+            cleanup_stale_files
+            return {success: true, message: "Daemon stopped gracefully"}
+          end
+        end
+
+        # Force kill if still running
+        Process.kill("KILL", daemon_pid)
+        cleanup_stale_files
+        {success: true, message: "Daemon force-killed after timeout"}
+      rescue Errno::ESRCH
+        cleanup_stale_files
+        {success: true, message: "Daemon already stopped"}
+      rescue => e
+        {success: false, message: "Error stopping daemon: #{e.message}"}
+      end
+
+      # Get socket path for IPC
+      attr_reader :socket_path
+
+      # Check if socket exists
+      def socket_exists?
+        File.exist?(@socket_path)
+      end
+
+      # Remove socket file
+      def remove_socket
+        File.delete(@socket_path) if File.exist?(@socket_path)
+      end
+
+      # Get log file path
+      def log_file_path
+        @log_path
+      end
+
+      private
+
+      def ensure_daemon_dir
+        daemon_dir = File.join(@project_dir, DAEMON_DIR)
+        FileUtils.mkdir_p(daemon_dir) unless Dir.exist?(daemon_dir)
+      end
+
+      def read_pid
+        return nil unless File.exist?(@pid_file_path)
+        File.read(@pid_file_path).strip.to_i
+      end
+
+      def process_exists?(daemon_pid)
+        Process.kill(0, daemon_pid)
+        true
+      rescue Errno::ESRCH
+        false
+      end
+
+      def cleanup_stale_files
+        remove_pid
+        remove_socket
+      end
+    end
+  end
+end

data/lib/aidp/daemon/runner.rb

@@ -0,0 +1,232 @@
+# frozen_string_literal: true
+
+require "socket"
+require_relative "process_manager"
+require_relative "../execute/async_work_loop_runner"
+
+module Aidp
+  module Daemon
+    # Main daemon runner for background mode execution
+    # Manages work loops, watch mode, and IPC communication
+    class Runner
+      def initialize(project_dir, config, options = {})
+        @project_dir = project_dir
+        @config = config
+        @options = options
+        @process_manager = ProcessManager.new(project_dir)
+        @running = false
+        @work_loop_runner = nil
+        @watch_runner = nil
+        @ipc_server = nil
+      end
+
+      # Start daemon in background
+      def start_daemon(mode: :watch)
+        if @process_manager.running?
+          return {success: false, message: "Daemon already running (PID: #{@process_manager.pid})"}
+        end
+
+        # Fork daemon process
+        daemon_pid = fork do
+          Process.daemon(true)
+          @process_manager.write_pid
+          run_daemon(mode)
+        end
+
+        Process.detach(daemon_pid)
+
+        # Wait for daemon to start
+        sleep 0.5
+
+        if @process_manager.running?
+          {
+            success: true,
+            message: "Daemon started in #{mode} mode",
+            pid: daemon_pid,
+            log_file: @process_manager.log_file_path
+          }
+        else
+          {success: false, message: "Failed to start daemon"}
+        end
+      end
+
+      # Attach to running daemon (restore REPL)
+      def attach
+        unless @process_manager.running?
+          return {success: false, message: "No daemon running"}
+        end
+
+        unless @process_manager.socket_exists?
+          return {success: false, message: "Daemon socket not available"}
+        end
+
+        {
+          success: true,
+          message: "Attached to daemon",
+          pid: @process_manager.pid,
+          activity: Aidp.logger.info("activity", "summary")
+        }
+      end
+
+      # Run daemon main loop (called in forked process)
+      def run_daemon(mode)
+        Aidp.logger.info("daemon_lifecycle", "Daemon started", mode: mode, pid: Process.pid)
+        @running = true
+
+        # Set up signal handlers
+        setup_signal_handlers
+
+        # Start IPC server
+        start_ipc_server
+
+        # Run appropriate mode
+        case mode
+        when :watch
+          run_watch_mode
+        when :work_loop
+          run_work_loop_mode
+        else
+          Aidp.logger.error("daemon_error", "Unknown mode: #{mode}")
+        end
+      rescue => e
+        Aidp.logger.error("daemon_error", "Fatal error: #{e.message}", backtrace: e.backtrace.first(5).join("\n"))
+      ensure
+        cleanup
+      end
+
+      private
+
+      def setup_signal_handlers
+        Signal.trap("TERM") do
+          Aidp.logger.info("daemon_lifecycle", "SIGTERM received, shutting down gracefully")
+          @running = false
+        end
+
+        Signal.trap("INT") do
+          Aidp.logger.info("daemon_lifecycle", "SIGINT received, shutting down gracefully")
+          @running = false
+        end
+      end
+
+      def start_ipc_server
+        # Create Unix socket for IPC
+        @ipc_server = UNIXServer.new(@process_manager.socket_path)
+
+        Thread.new do
+          while @running
+            begin
+              client = @ipc_server.accept_nonblock
+              handle_ipc_client(client)
+            rescue IO::WaitReadable
+              IO.select([@ipc_server], nil, nil, 1)
+            rescue => e
+              Aidp.logger.error("ipc_error", "IPC server error: #{e.message}")
+            end
+          end
+        end
+      rescue => e
+        Aidp.logger.error("ipc_error", "Failed to start IPC server: #{e.message}")
+      end
+
+      def handle_ipc_client(client)
+        command = client.gets&.strip
+        return unless command
+
+        response = case command
+        when "status"
+          status_response
+        when "stop"
+          stop_response
+        when "attach"
+          attach_response
+        else
+          {error: "Unknown command: #{command}"}
+        end
+
+        client.puts(response.to_json)
+        client.close
+      rescue => e
+        Aidp.logger.error("ipc_error", "Error handling client: #{e.message}")
+        begin
+          client.close
+        rescue
+          nil
+        end
+      end
+
+      def status_response
+        {
+          status: "running",
+          pid: Process.pid,
+          mode: @watch_runner ? "watch" : "work_loop",
+          uptime: Time.now.to_i
+        }
+      end
+
+      def stop_response
+        @running = false
+        {status: "stopping"}
+      end
+
+      def attach_response
+        {
+          status: "attached",
+          activity: Aidp.logger.info("activity", "summary")
+        }
+      end
+
+      def run_watch_mode
+        Aidp.logger.info("watch_mode", "Starting watch mode")
+
+        # Initialize watch runner
+        require_relative "../watch/runner"
+        @watch_runner = Aidp::Watch::Runner.new(@project_dir, @config, @options)
+
+        while @running
+          begin
+            @watch_runner.run_cycle
+            Aidp.logger.info("watch_mode", "Watch cycle completed")
+            sleep(@options[:interval] || 60)
+          rescue => e
+            Aidp.logger.error("watch_error", "Watch cycle error: #{e.message}")
+            sleep 30 # Back off on error
+          end
+        end
+
+        Aidp.logger.info("watch_mode", "Watch mode stopped")
+      end
+
+      def run_work_loop_mode
+        Aidp.logger.info("daemon_lifecycle", "Starting work loop mode")
+
+        # This would integrate with AsyncWorkLoopRunner
+        # For now, just log that we're running
+        while @running
+          Aidp.logger.debug("heartbeat", "Daemon running")
+          sleep 10
+        end
+
+        Aidp.logger.info("daemon_lifecycle", "Work loop mode stopped")
+      end
+
+      def cleanup
+        Aidp.logger.info("daemon_lifecycle", "Daemon cleanup started")
+
+        # Stop work loop if running
+        @work_loop_runner&.cancel(save_checkpoint: true)
+
+        # Stop watch runner if running
+        @watch_runner = nil
+
+        # Close IPC server
+        @ipc_server&.close
+        @process_manager.remove_socket
+
+        # Remove PID file
+        @process_manager.remove_pid
+
+        Aidp.logger.info("daemon_lifecycle", "Daemon stopped cleanly")
+      end
+    end
+  end
+end

data/lib/aidp/execute/async_work_loop_runner.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+require_relative "work_loop_runner"
+require_relative "work_loop_state"
+require_relative "instruction_queue"
+
+module Aidp
+  module Execute
+    # Asynchronous wrapper around WorkLoopRunner
+    # Runs work loop in a separate thread while maintaining REPL responsiveness
+    #
+    # Responsibilities:
+    # - Execute work loop in background thread
+    # - Monitor execution state (pause, resume, cancel)
+    # - Merge queued instructions at iteration boundaries
+    # - Stream output to main thread for display
+    # - Handle graceful cancellation with checkpoint save
+    class AsyncWorkLoopRunner
+      attr_reader :state, :instruction_queue, :work_thread
+
+      def initialize(project_dir, provider_manager, config, options = {})
+        @project_dir = project_dir
+        @provider_manager = provider_manager
+        @config = config
+        @options = options
+        @state = WorkLoopState.new
+        @instruction_queue = InstructionQueue.new
+        @work_thread = nil
+        @sync_runner = nil
+      end
+
+      # Start async work loop execution
+      # Returns immediately, work continues in background thread
+      def execute_step_async(step_name, step_spec, context = {})
+        raise WorkLoopState::StateError, "Work loop already running" unless @state.idle?
+
+        @state.start!
+        @step_name = step_name
+        @step_spec = step_spec
+        @context = context
+
+        @work_thread = Thread.new do
+          run_async_loop
+        rescue => e
+          @state.error!(e)
+          @state.append_output("Work loop error: #{e.message}", type: :error)
+        ensure
+          @work_thread = nil
+        end
+
+        # Allow thread to start
+        Thread.pass
+
+        {status: "started", state: @state.summary}
+      end
+
+      # Wait for work loop to complete (blocking)
+      def wait
+        return unless @work_thread
+        @work_thread.join
+        build_final_result
+      end
+
+      # Check if work loop is running
+      def running?
+        @work_thread&.alive? && @state.running?
+      end
+
+      # Pause execution
+      def pause
+        return unless running?
+        @state.pause!
+        {status: "paused", iteration: @state.iteration}
+      end
+
+      # Resume execution
+      def resume
+        return unless @state.paused?
+        @state.resume!
+        {status: "resumed", iteration: @state.iteration}
+      end
+
+      # Cancel execution gracefully
+      def cancel(save_checkpoint: true)
+        return if @state.cancelled? || @state.completed?
+
+        @state.cancel!
+        @state.append_output("Cancellation requested, waiting for safe stopping point...", type: :warning)
+
+        # Wait for thread to notice cancellation
+        @work_thread&.join(5) # 5 second timeout
+
+        if save_checkpoint && @sync_runner
+          @state.append_output("Saving checkpoint before exit...", type: :info)
+          save_cancellation_checkpoint
+        end
+
+        {status: "cancelled", iteration: @state.iteration}
+      end
+
+      # Add instruction to queue (will be merged at next iteration)
+      def enqueue_instruction(content, type: :user_input, priority: :normal)
+        @instruction_queue.enqueue(content, type: type, priority: priority)
+        @state.enqueue_instruction(content)
+
+        {
+          status: "enqueued",
+          queued_count: @instruction_queue.count,
+          message: "Instruction will be merged in next iteration"
+        }
+      end
+
+      # Get streaming output
+      def drain_output
+        @state.drain_output
+      end
+
+      # Get current status
+      def status
+        summary = @state.summary
+        summary[:queued_instructions] = @instruction_queue.summary
+        summary[:thread_alive] = @work_thread&.alive? || false
+        summary
+      end
+
+      private
+
+      # Main async execution loop
+      def run_async_loop
+        # Create synchronous runner (runs in this thread)
+        @sync_runner = WorkLoopRunner.new(
+          @project_dir,
+          @provider_manager,
+          @config,
+          @options.merge(async_mode: true)
+        )
+
+        @state.append_output("🚀 Starting async work loop: #{@step_name}", type: :info)
+
+        # Hook into sync runner to check for pause/cancel
+        result = execute_with_monitoring
+
+        if @state.cancelled?
+          @state.append_output("Work loop cancelled at iteration #{@state.iteration}", type: :warning)
+        else
+          @state.complete!
+          @state.append_output("✅ Work loop completed: #{@step_name}", type: :success)
+        end
+
+        result
+      rescue => e
+        @state.error!(e)
+        @state.append_output("Error in work loop: #{e.message}\n#{e.backtrace.first(3).join("\n")}", type: :error)
+        raise
+      end
+
+      # Execute sync runner with monitoring for control signals
+      def execute_with_monitoring
+        # We need to modify WorkLoopRunner to support iteration callbacks
+        # For now, we'll wrap the execute_step call
+        #
+        # TODO: This requires enhancing WorkLoopRunner to accept iteration callbacks
+        # See: https://github.com/viamin/aidp/issues/103
+        @sync_runner.execute_step(@step_name, @step_spec, @context)
+      end
+
+      # Save checkpoint when cancelling
+      def save_cancellation_checkpoint
+        return unless @sync_runner
+
+        checkpoint = @sync_runner.instance_variable_get(:@checkpoint)
+        return unless checkpoint
+
+        checkpoint.record_checkpoint(
+          @step_name,
+          @state.iteration,
+          {
+            cancelled: true,
+            reason: "User cancelled via REPL",
+            queued_instructions: @instruction_queue.count
+          }
+        )
+      end
+
+      # Build final result from state
+      def build_final_result
+        if @state.completed?
+          {
+            status: "completed",
+            iterations: @state.iteration,
+            message: "Work loop completed successfully"
+          }
+        elsif @state.cancelled?
+          {
+            status: "cancelled",
+            iterations: @state.iteration,
+            message: "Work loop cancelled by user"
+          }
+        elsif @state.error?
+          {
+            status: "error",
+            iterations: @state.iteration,
+            error: @state.last_error&.message,
+            message: "Work loop encountered an error"
+          }
+        else
+          {
+            status: "unknown",
+            iterations: @state.iteration,
+            message: "Work loop ended in unknown state"
+          }
+        end
+      end
+    end
+  end
+end