rubyn-code 0.1.0

data/lib/rubyn_code/autonomous/idle_poller.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module Autonomous
+    # Polls for new work when an agent is idle. Checks the mailbox
+    # (messages always take priority) and the task board on a regular
+    # interval. Blocks the calling thread until work is found, the
+    # idle timeout expires, or the poller is interrupted.
+    class IdlePoller
+      # @param mailbox [#pending_for] message mailbox
+      # @param task_manager [#db] task persistence layer
+      # @param agent_name [String] the polling agent's identifier
+      # @param poll_interval [Numeric] seconds between polls (default 5)
+      # @param idle_timeout [Numeric] max seconds to wait before shutdown (default 60)
+      def initialize(mailbox:, task_manager:, agent_name:, poll_interval: 5, idle_timeout: 60)
+        @mailbox = mailbox
+        @task_manager = task_manager
+        @agent_name = agent_name
+        @poll_interval = poll_interval
+        @idle_timeout = idle_timeout
+        @interrupted = false
+      end
+
+      # Blocks the caller, polling for new work at the configured interval.
+      #
+      # @return [:resume, :shutdown, :interrupted]
+      #   - :resume     - found work (message or task)
+      #   - :shutdown   - idle timeout elapsed with no work
+      #   - :interrupted - #interrupt! was called externally
+      def poll!
+        deadline = monotonic_now + @idle_timeout
+
+        loop do
+          return :interrupted if @interrupted
+          return :shutdown if monotonic_now >= deadline
+
+          # Messages always take priority over tasks.
+          if has_pending_messages?
+            return :resume
+          end
+
+          if has_claimable_task?
+            return :resume
+          end
+
+          remaining = deadline - monotonic_now
+          return :shutdown if remaining <= 0
+
+          sleep [remaining, @poll_interval].min
+        end
+      end
+
+      # Signals the poller to stop at the next iteration.
+      #
+      # @return [void]
+      def interrupt!
+        @interrupted = true
+      end
+
+      # Re-injects the agent's identity message when the conversation
+      # context has been compressed (i.e. the messages array is very short).
+      # This ensures the agent still knows who it is after compaction.
+      #
+      # @param messages [Array<Hash>] the current conversation messages
+      # @param identity [String] the identity/system prompt to re-inject
+      # @param threshold [Integer] message count below which re-injection triggers (default 3)
+      # @return [void]
+      def self.reinject_identity(messages, identity:, threshold: 3)
+        return if messages.length >= threshold
+        return if identity.nil? || identity.empty?
+
+        # Only re-inject if the identity is not already present as the
+        # first user message.
+        first_user = messages.find { |m| m[:role] == "user" }
+        return if first_user && first_user[:content].to_s.include?(identity[0, 100])
+
+        messages.unshift({ role: "user", content: identity })
+      end
+
+      private
+
+      # @return [Boolean]
+      def has_pending_messages?
+        messages = @mailbox.pending_for(@agent_name)
+        messages.is_a?(Array) ? !messages.empty? : false
+      rescue StandardError
+        false
+      end
+
+      # @return [Boolean]
+      def has_claimable_task?
+        rows = @task_manager.db.query(<<~SQL).to_a
+          SELECT 1 FROM tasks
+          WHERE status = 'pending'
+            AND (owner IS NULL OR owner = '')
+          LIMIT 1
+        SQL
+        !rows.empty?
+      rescue StandardError
+        false
+      end
+
+      # Monotonic clock to avoid issues with wall-clock adjustments.
+      #
+      # @return [Float] seconds
+      def monotonic_now
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+    end
+  end
+end

data/lib/rubyn_code/autonomous/task_claimer.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module Autonomous
+    # Claims and prepares unclaimed tasks for agent execution.
+    # Uses optimistic locking to handle race conditions when multiple
+    # agents attempt to claim the same task concurrently.
+    module TaskClaimer
+      # Finds the first ready (pending, unowned) task, claims it for the
+      # given agent, and returns the updated Task. Returns nil if no work
+      # is available.
+      #
+      # @param task_manager [#db, #update_task, #list_tasks] task persistence layer
+      # @param agent_name [String] unique identifier of the claiming agent
+      # @return [Tasks::Task, nil] the claimed task, or nil if none available
+      def self.call(task_manager:, agent_name:)
+        db = task_manager.db
+
+        # Atomically claim the first eligible task. The WHERE conditions
+        # ensure that only pending tasks with no current owner are touched,
+        # avoiding race conditions with other agents.
+        db.execute(<<~SQL, [agent_name])
+          UPDATE tasks
+          SET owner = ?,
+              status = 'in_progress',
+              updated_at = datetime('now')
+          WHERE id = (
+            SELECT id FROM tasks
+            WHERE status = 'pending'
+              AND (owner IS NULL OR owner = '')
+            ORDER BY priority DESC, created_at ASC
+            LIMIT 1
+          )
+          AND status = 'pending'
+          AND (owner IS NULL OR owner = '')
+        SQL
+
+        # Fetch the task we just claimed. Using owner + status filters
+        # ensures we only retrieve a task that *this* agent successfully
+        # claimed (another agent cannot have flipped it in between).
+        rows = db.query(<<~SQL, [agent_name]).to_a
+          SELECT id, session_id, title, description, status,
+                 priority, owner, result, metadata, created_at, updated_at
+          FROM tasks
+          WHERE owner = ?
+            AND status = 'in_progress'
+          ORDER BY updated_at DESC
+          LIMIT 1
+        SQL
+
+        return nil if rows.empty?
+
+        row = rows.first
+        build_task(row)
+      rescue StandardError => e
+        # If anything goes wrong (e.g. task was already claimed between
+        # our SELECT and UPDATE, or a constraint violation) we treat it
+        # as "no work available" rather than crashing the daemon.
+        RubynCode.logger.warn("TaskClaimer: failed to claim task: #{e.message}") if RubynCode.respond_to?(:logger)
+        nil
+      end
+
+      class << self
+        private
+
+        # @param row [Hash] a database row hash
+        # @return [Tasks::Task]
+        def build_task(row)
+          metadata = parse_json(row["metadata"])
+
+          Tasks::Task.new(
+            id: row["id"],
+            session_id: row["session_id"],
+            title: row["title"],
+            description: row["description"],
+            status: row["status"],
+            priority: row["priority"].to_i,
+            owner: row["owner"],
+            result: row["result"],
+            metadata: metadata,
+            created_at: row["created_at"],
+            updated_at: row["updated_at"]
+          )
+        end
+
+        # @param raw [String, Hash, nil]
+        # @return [Hash]
+        def parse_json(raw)
+          case raw
+          when Hash then raw
+          when String then JSON.parse(raw, symbolize_names: true)
+          else {}
+          end
+        rescue JSON::ParserError
+          {}
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/background/job.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module Background
+    Job = Data.define(:id, :command, :status, :result, :started_at, :completed_at) do
+      def running?   = status == :running
+      def completed? = status == :completed
+      def error?     = status == :error
+      def timeout?   = status == :timeout
+
+      def duration
+        return nil unless started_at
+        return nil if running?
+
+        (completed_at || Time.now) - started_at
+      end
+    end
+  end
+end

data/lib/rubyn_code/background/notifier.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "thread"
+
+module RubynCode
+  module Background
+    # Thread-safe notification queue for background job completions.
+    # Uses Ruby's stdlib Queue which is already thread-safe for push/pop,
+    # but we guard drain with a mutex to prevent interleaved partial drains.
+    class Notifier
+      def initialize
+        @queue = Queue.new
+        @drain_mutex = Mutex.new
+      end
+
+      # Enqueues a notification.
+      #
+      # @param notification [Hash, String, Object] arbitrary notification payload
+      # @return [void]
+      def push(notification)
+        @queue.push(notification)
+      end
+
+      # Drains all pending notifications in a single atomic operation.
+      # Returns an empty array if nothing is pending.
+      #
+      # @return [Array] all pending notifications
+      def drain
+        @drain_mutex.synchronize do
+          notifications = []
+          notifications << @queue.pop until @queue.empty?
+          notifications
+        end
+      end
+
+      # Returns true if there are notifications waiting.
+      #
+      # @return [Boolean]
+      def pending?
+        !@queue.empty?
+      end
+    end
+  end
+end

data/lib/rubyn_code/background/worker.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require "open3"
+require "securerandom"
+require "timeout"
+require_relative "job"
+require_relative "notifier"
+
+module RubynCode
+  module Background
+    # Runs shell commands in background threads with configurable timeouts.
+    # Thread-safe job tracking with a hard cap on concurrency.
+    class Worker
+      MAX_CONCURRENT = 5
+
+      # @param project_root [String] working directory for spawned commands
+      # @param notifier [Notifier] notification queue for completed jobs
+      def initialize(project_root:, notifier: Notifier.new)
+        @project_root = File.expand_path(project_root)
+        @notifier = notifier
+        @jobs = {}
+        @threads = {}
+        @mutex = Mutex.new
+      end
+
+      # Spawns a background thread to run the given command.
+      #
+      # @param command [String] the shell command to execute
+      # @param timeout [Integer] timeout in seconds (default 120)
+      # @return [String] the job ID
+      # @raise [RuntimeError] if the concurrency cap is reached
+      def run(command, timeout: 120)
+        job_id = SecureRandom.uuid
+
+        @mutex.synchronize do
+          running = @jobs.count { |_, j| j.running? }
+          if running >= MAX_CONCURRENT
+            raise "Concurrency limit reached (#{MAX_CONCURRENT} jobs running). Wait for a job to finish."
+          end
+
+          job = Job.new(
+            id: job_id,
+            command: command,
+            status: :running,
+            result: nil,
+            started_at: Time.now,
+            completed_at: nil
+          )
+          @jobs[job_id] = job
+        end
+
+        thread = Thread.new { execute_job(job_id, command, timeout) }
+        thread.abort_on_exception = false
+
+        @mutex.synchronize { @threads[job_id] = thread }
+
+        job_id
+      end
+
+      # Returns the current state of a job.
+      #
+      # @param job_id [String]
+      # @return [Job, nil]
+      def status(job_id)
+        @mutex.synchronize { @jobs[job_id] }
+      end
+
+      # Delegates to the notifier to drain all pending notifications.
+      #
+      # @return [Array]
+      def drain_notifications
+        @notifier.drain
+      end
+
+      # Returns the number of currently running jobs.
+      #
+      # @return [Integer]
+      def active_count
+        @mutex.synchronize do
+          @jobs.count { |_, j| j.running? }
+        end
+      end
+
+      # Waits for all running threads to finish. Intended for graceful shutdown.
+      #
+      # @param timeout [Integer] maximum seconds to wait per thread (default 30)
+      # @return [void]
+      def shutdown!(timeout: 30)
+        threads = @mutex.synchronize { @threads.values.dup }
+        threads.each { |t| t.join(timeout) }
+      end
+
+      private
+
+      def execute_job(job_id, command, timeout_seconds)
+        stdout, stderr, process_status = nil
+        final_status = :completed
+
+        begin
+          Timeout.timeout(timeout_seconds) do
+            stdout, stderr, process_status = Open3.capture3(command, chdir: @project_root)
+          end
+
+          final_status = process_status.success? ? :completed : :error
+        rescue Timeout::Error
+          final_status = :timeout
+          stdout = nil
+          stderr = "Command timed out after #{timeout_seconds} seconds"
+        rescue StandardError => e
+          final_status = :error
+          stdout = nil
+          stderr = e.message
+        end
+
+        result = build_result(stdout, stderr)
+        completed_at = Time.now
+
+        completed_job = @mutex.synchronize do
+          @jobs[job_id] = Job.new(
+            id: job_id,
+            command: command,
+            status: final_status,
+            result: result,
+            started_at: @jobs[job_id].started_at,
+            completed_at: completed_at
+          )
+        end
+
+        @notifier.push({
+          type: :job_completed,
+          job_id: job_id,
+          status: final_status,
+          result: result,
+          duration: completed_job.duration
+        })
+      end
+
+      def build_result(stdout, stderr)
+        parts = []
+        parts << stdout if stdout && !stdout.empty?
+        parts << "STDERR: #{stderr}" if stderr && !stderr.empty?
+        parts.empty? ? "(no output)" : parts.join("\n")
+      end
+    end
+  end
+end

data/lib/rubyn_code/cli/app.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    class App
+      def self.start(argv)
+        new(argv).run
+      end
+
+      def initialize(argv)
+        @argv = argv
+        @options = parse_options(argv)
+      end
+
+      def run
+        case @options[:command]
+        when :version
+          puts "rubyn-code #{RubynCode::VERSION}"
+        when :auth
+          run_auth
+        when :help
+          display_help
+        when :run
+          run_single_prompt(@options[:prompt])
+        when :repl
+          run_repl
+        end
+      end
+
+      private
+
+      def parse_options(argv)
+        options = { command: :repl }
+
+        i = 0
+        while i < argv.length
+          case argv[i]
+          when "--version", "-v"
+            options[:command] = :version
+          when "--help", "-h"
+            options[:command] = :help
+          when "--auth"
+            options[:command] = :auth
+          when "--resume", "-r"
+            options[:session_id] = argv[i + 1]
+            i += 1
+          when "-p", "--prompt"
+            options[:command] = :run
+            options[:prompt] = argv[i + 1]
+            i += 1
+          when "--yolo"
+            options[:yolo] = true
+          end
+          i += 1
+        end
+
+        options
+      end
+
+      def run_auth
+        renderer = Renderer.new
+        renderer.info("Starting Claude OAuth authentication...")
+
+        begin
+          Auth::OAuth.new.authenticate!
+          renderer.success("Authentication successful! Token stored.")
+        rescue AuthenticationError => e
+          renderer.error("Authentication failed: #{e.message}")
+          exit(1)
+        end
+      end
+
+      def run_single_prompt(prompt)
+        return display_help unless prompt
+
+        repl = REPL.new(project_root: Dir.pwd)
+        # Non-interactive: send one message and exit
+        response = repl.instance_variable_get(:@agent_loop).send_message(prompt)
+        puts response
+      end
+
+      def run_repl
+        REPL.new(
+          session_id: @options[:session_id],
+          project_root: Dir.pwd,
+          yolo: @options[:yolo]
+        ).run
+      end
+
+      def display_help
+        puts <<~HELP
+          rubyn-code - Ruby & Rails Agentic Coding Assistant
+
+          Usage:
+            rubyn-code                    Start interactive REPL
+            rubyn-code -p "prompt"        Run a single prompt and exit
+            rubyn-code --resume [ID]      Resume a previous session
+            rubyn-code --auth             Authenticate with Claude
+            rubyn-code --version          Show version
+            rubyn-code --help             Show this help
+
+          Interactive Commands:
+            /help          Show available commands
+            /quit          Exit
+            /compact       Compress context
+            /cost          Show usage costs
+            /tasks         List tasks
+            /skill [name]  Load or list skills
+
+          Environment:
+            Config:  ~/.rubyn-code/config.yml
+            Data:    ~/.rubyn-code/rubyn_code.db
+            Tokens:  ~/.rubyn-code/tokens.yml
+        HELP
+      end
+    end
+  end
+end

data/lib/rubyn_code/cli/input_handler.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    class InputHandler
+      SLASH_COMMANDS = {
+        "/quit" => :quit,
+        "/exit" => :quit,
+        "/q" => :quit,
+        "/compact" => :compact,
+        "/cost" => :cost,
+        "/clear" => :clear,
+        "/undo" => :undo,
+        "/help" => :help,
+        "/tasks" => :tasks,
+        "/budget" => :budget,
+        "/resume" => :resume,
+        "/skill" => :skill,
+        "/version" => :version,
+        "/review" => :review,
+        "/spawn" => :spawn_teammate
+      }.freeze
+
+      Command = Data.define(:action, :args)
+
+      def parse(input)
+        return Command.new(action: :quit, args: []) if input.nil?
+
+        stripped = input.strip
+        return Command.new(action: :empty, args: []) if stripped.empty?
+
+        if stripped.start_with?("/")
+          parse_slash_command(stripped)
+        else
+          Command.new(action: :message, args: [process_file_references(stripped)])
+        end
+      end
+
+      def multiline?(line)
+        line&.end_with?("\\")
+      end
+
+      def strip_continuation(line)
+        line.chomp("\\")
+      end
+
+      private
+
+      def parse_slash_command(input)
+        return Command.new(action: :list_commands, args: []) if input.strip == "/"
+
+        parts = input.split(/\s+/, 2)
+        cmd = parts[0].downcase
+        args = parts[1]&.split(/\s+/) || []
+
+        action = SLASH_COMMANDS[cmd]
+
+        if action
+          Command.new(action: action, args: args)
+        else
+          Command.new(action: :unknown_command, args: [cmd])
+        end
+      end
+
+      def process_file_references(input)
+        input.gsub(/@(\S+)/) do |match|
+          path = Regexp.last_match(1)
+          if File.exist?(path)
+            content = File.read(path, encoding: "utf-8")
+            truncated = content.length > 50_000 ? "#{content[0...50_000]}\n[truncated]" : content
+            "\n<file path=\"#{path}\">\n#{truncated}\n</file>\n"
+          else
+            match
+          end
+        end
+      end
+    end
+  end
+end