rubyn-code 0.1.0 → 0.2.0

data/lib/rubyn_code/autonomous/task_claimer.rb

@@ -66,20 +66,20 @@ module RubynCode
         # @param row [Hash] a database row hash
         # @return [Tasks::Task]
         def build_task(row)
-          metadata = parse_json(row["metadata"])
+          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"],
+            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"]
+            created_at: row['created_at'],
+            updated_at: row['updated_at']
           )
         end
 

data/lib/rubyn_code/background/RUBYN.md

@@ -0,0 +1,13 @@
+# Layer 8: Background
+
+Background job execution for long-running commands.
+
+## Classes
+
+- **`Worker`** — Manages background processes. Spawns commands in subprocesses,
+  tracks their PIDs, and collects output when complete.
+
+- **`Job`** — Represents a single background job: command, PID, status, output.
+
+- **`Notifier`** — Delivers background job results back to the agent. Injects completed
+  job output into the conversation before the next LLM call.

data/lib/rubyn_code/background/notifier.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "thread"
-
 module RubynCode
   module Background
     # Thread-safe notification queue for background job completions.

data/lib/rubyn_code/background/worker.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require "open3"
-require "securerandom"
-require "timeout"
-require_relative "job"
-require_relative "notifier"
+require 'open3'
+require 'securerandom'
+require 'timeout'
+require_relative 'job'
+require_relative 'notifier'
 
 module RubynCode
   module Background
@@ -93,14 +93,59 @@ module RubynCode
       private
 
       def execute_job(job_id, command, timeout_seconds)
-        stdout, stderr, process_status = nil
+        stdout, stderr, = nil
         final_status = :completed
 
         begin
-          Timeout.timeout(timeout_seconds) do
-            stdout, stderr, process_status = Open3.capture3(command, chdir: @project_root)
+          stdin_io, stdout_io, stderr_io, wait_thr = Open3.popen3(command, chdir: @project_root)
+          stdin_io.close
+          out_buf = +''
+          err_buf = +''
+          out_reader = Thread.new do
+            out_buf << stdout_io.read
+          rescue StandardError
+            nil
+          end
+          err_reader = Thread.new do
+            err_buf << stderr_io.read
+          rescue StandardError
+            nil
+          end
+
+          unless wait_thr.join(timeout_seconds)
+            begin
+              Process.kill('TERM', wait_thr.pid)
+            rescue StandardError
+              nil
+            end
+            sleep 0.1
+            begin
+              Process.kill('KILL', wait_thr.pid)
+            rescue StandardError
+              nil
+            end
+            wait_thr.join(5)
+            out_reader.join(2)
+            err_reader.join(2)
+            [stdout_io, stderr_io].each do |io|
+              io.close
+            rescue StandardError
+              nil
+            end
+            raise Timeout::Error
+          end
+
+          out_reader.join(5)
+          err_reader.join(5)
+          [stdout_io, stderr_io].each do |io|
+            io.close
+          rescue StandardError
+            nil
           end
 
+          stdout = out_buf
+          stderr = err_buf
+          process_status = wait_thr.value
           final_status = process_status.success? ? :completed : :error
         rescue Timeout::Error
           final_status = :timeout
@@ -127,19 +172,19 @@ module RubynCode
         end
 
         @notifier.push({
-          type: :job_completed,
-          job_id: job_id,
-          status: final_status,
-          result: result,
-          duration: completed_job.duration
-        })
+                         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")
+        parts.empty? ? '(no output)' : parts.join("\n")
       end
     end
   end

data/lib/rubyn_code/cli/RUBYN.md

@@ -0,0 +1,30 @@
+# CLI Layer
+
+Terminal interface. Entry point → REPL → rendering.
+
+## Classes
+
+- **`App`** — Parses ARGV into commands (`:version`, `:auth`, `:help`, `:run`, `:repl`) and dispatches.
+  `App.start(ARGV)` is the gem's entry point from `exe/rubyn-code`.
+
+- **`REPL`** — Read-eval-print loop. Wires up InputHandler for parsing, Agent::Loop for execution,
+  Renderer for output. Delegates `/slash` commands to the Commands::Registry.
+
+- **`InputHandler`** — Maps user input to `Command` structs (a `Data.define`). Classifies input
+  as `:command`, `:message`, or `:quit`. Registry-driven — no hardcoded command list.
+
+- **`Renderer`** — Renders LLM responses to the terminal. Uses Pastel for colors,
+  Rouge (Monokai theme) for syntax highlighting. Has a `yolo` writer for permission bypass display.
+
+- **`Spinner`** — TTY::Spinner wrapper for thinking/working indicators.
+
+- **`StreamFormatter`** — Handles real-time streaming output from the LLM, buffering partial
+  markdown and flushing complete lines with syntax highlighting.
+
+## Commands Subsystem
+
+See [`commands/RUBYN.md`](commands/RUBYN.md) for full docs.
+
+19 slash commands, each in its own file under `cli/commands/`. Registry-based dispatch
+with tab-completion. Commands return optional **action hashes** for REPL state changes
+(model switch, plan mode toggle, budget updates, etc.).

data/lib/rubyn_code/cli/app.rb

@@ -13,15 +13,21 @@ module RubynCode
       end
 
       def run
+        RubynCode::Debug.enable! if @options[:debug]
+
         case @options[:command]
         when :version
           puts "rubyn-code #{RubynCode::VERSION}"
         when :auth
           run_auth
+        when :setup
+          run_setup
         when :help
           display_help
         when :run
           run_single_prompt(@options[:prompt])
+        when :daemon
+          run_daemon
         when :repl
           run_repl
         end
@@ -29,27 +35,35 @@ module RubynCode
 
       private
 
-      def parse_options(argv)
+      def parse_options(argv) # rubocop:disable Metrics/MethodLength,Metrics/CyclomaticComplexity
         options = { command: :repl }
 
         i = 0
         while i < argv.length
           case argv[i]
-          when "--version", "-v"
+          when '--version', '-v'
             options[:command] = :version
-          when "--help", "-h"
+          when '--help', '-h'
             options[:command] = :help
-          when "--auth"
+          when '--auth'
             options[:command] = :auth
-          when "--resume", "-r"
+          when '--resume', '-r'
             options[:session_id] = argv[i + 1]
             i += 1
-          when "-p", "--prompt"
+          when '-p', '--prompt'
             options[:command] = :run
             options[:prompt] = argv[i + 1]
             i += 1
-          when "--yolo"
+          when '--yolo'
             options[:yolo] = true
+          when '--debug'
+            options[:debug] = true
+          when '--setup'
+            options[:command] = :setup
+          when 'daemon'
+            options[:command] = :daemon
+            parse_daemon_options!(argv, i + 1, options)
+            break
           end
           i += 1
         end
@@ -57,19 +71,67 @@ module RubynCode
         options
       end
 
+      # Parses daemon-specific flags from the argv starting at the given index.
+      #
+      # @param argv [Array<String>]
+      # @param start [Integer]
+      # @param options [Hash]
+      # @return [void]
+      def parse_daemon_options!(argv, start, options) # rubocop:disable Metrics/MethodLength,Metrics/CyclomaticComplexity
+        options[:daemon] = {
+          max_runs: 100,
+          max_cost: 10.0,
+          idle_timeout: 60,
+          poll_interval: 5,
+          agent_name: "golem-#{SecureRandom.hex(4)}",
+          role: 'autonomous coding agent'
+        }
+
+        i = start
+        while i < argv.length
+          case argv[i]
+          when '--max-runs'
+            options[:daemon][:max_runs] = argv[i + 1].to_i
+            i += 1
+          when '--max-cost'
+            options[:daemon][:max_cost] = argv[i + 1].to_f
+            i += 1
+          when '--idle-timeout'
+            options[:daemon][:idle_timeout] = argv[i + 1].to_i
+            i += 1
+          when '--poll-interval'
+            options[:daemon][:poll_interval] = argv[i + 1].to_i
+            i += 1
+          when '--name'
+            options[:daemon][:agent_name] = argv[i + 1]
+            i += 1
+          when '--role'
+            options[:daemon][:role] = argv[i + 1]
+            i += 1
+          when '--debug'
+            options[:debug] = true
+          end
+          i += 1
+        end
+      end
+
       def run_auth
         renderer = Renderer.new
-        renderer.info("Starting Claude OAuth authentication...")
+        renderer.info('Starting Claude OAuth authentication...')
 
         begin
           Auth::OAuth.new.authenticate!
-          renderer.success("Authentication successful! Token stored.")
+          renderer.success('Authentication successful! Token stored.')
         rescue AuthenticationError => e
           renderer.error("Authentication failed: #{e.message}")
           exit(1)
         end
       end
 
+      def run_setup
+        Setup.run
+      end
+
       def run_single_prompt(prompt)
         return display_help unless prompt
 
@@ -79,6 +141,10 @@ module RubynCode
         puts response
       end
 
+      def run_daemon
+        DaemonRunner.new(@options).run
+      end
+
       def run_repl
         REPL.new(
           session_id: @options[:session_id],
@@ -95,10 +161,20 @@ module RubynCode
             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 --setup            Pin rubyn-code to bypass rbenv/rvm
             rubyn-code --auth             Authenticate with Claude
             rubyn-code --version          Show version
             rubyn-code --help             Show this help
 
+          Daemon Mode:
+            rubyn-code daemon             Start autonomous daemon (GOLEM)
+            rubyn-code daemon --name NAME Agent name (default: golem-<random>)
+            rubyn-code daemon --role ROLE Agent role description
+            rubyn-code daemon --max-runs N     Max tasks before shutdown (default: 100)
+            rubyn-code daemon --max-cost N     Max USD spend before shutdown (default: 10.0)
+            rubyn-code daemon --idle-timeout N Seconds idle before shutdown (default: 60)
+            rubyn-code daemon --poll-interval N Seconds between polls (default: 5)
+
           Interactive Commands:
             /help          Show available commands
             /quit          Exit

data/lib/rubyn_code/cli/commands/RUBYN.md

@@ -0,0 +1,133 @@
+# CLI::Commands — Slash Command System
+
+> Registry-based command dispatch for the REPL. Same Base/Registry pattern as the tool system.
+
+## Architecture
+
+```
+User types /help
+    ↓
+InputHandler.classify → :command
+    ↓
+REPL#handle_command
+    ↓
+Registry#dispatch('/help', args, context)
+    ↓
+Help#execute(args, context)
+    ↓
+(optional) → action hash back to REPL for state changes
+```
+
+### Core Infrastructure
+
+| File | Class | Purpose |
+|------|-------|---------|
+| `base.rb` | `Base` | Abstract command — `command_name`, `description`, `aliases`, `execute(args, ctx)` |
+| `registry.rb` | `Registry` | Discovers, registers, dispatches commands. Provides tab-completion list |
+| `context.rb` | `Context` | `Data.define` value object with all deps a command needs |
+
+### Context Object
+
+`Context` is a frozen `Data.define` carrying everything a command might need:
+
+```ruby
+Context = Data.define(
+  :renderer, :conversation, :agent_loop, :context_manager,
+  :budget_enforcer, :llm_client, :db, :session_id,
+  :project_root, :skill_loader, :session_persistence,
+  :background_worker, :permission_tier, :plan_mode
+)
+```
+
+Commands receive it as the second argument to `execute`. Never mutate it — use
+`with_message_handler` to attach a message callback if the command needs to send
+prompts back to the agent loop.
+
+## Commands
+
+| Command | File | Description |
+|---------|------|-------------|
+| `/budget` | `budget.rb` | Show or set session budget (/budget [amount]) |
+| `/clear` | `clear.rb` | Clear the terminal |
+| `/compact` | `compact.rb` | Compress conversation context |
+| `/context` | `context_info.rb` | Show context window usage |
+| `/cost` | `cost.rb` | Show token usage and costs |
+| `/diff` | `diff.rb` | Show git diff (staged, unstaged, or vs branch) |
+| `/doctor` | `doctor.rb` | Environment health check |
+| `/help` | `help.rb` | Show this help message |
+| `/model` | `model.rb` | Show or switch model (/model [name]) |
+| `/plan` | `plan.rb` | Toggle plan mode (think before acting) |
+| `/quit` | `quit.rb` | Exit Rubyn Code (aliases: `/exit`, `/q`) |
+| `/resume` | `resume.rb` | Resume a session or list recent sessions |
+| `/review` | `review.rb` | Review current branch against best practices |
+| `/skill` | `skill.rb` | Load a skill or list available skills |
+| `/spawn` | `spawn.rb` | Spawn a teammate agent (/spawn \<name\> [role]) |
+| `/tasks` | `tasks.rb` | List all tasks |
+| `/tokens` | `tokens.rb` | Show token usage and context window estimate |
+| `/undo` | `undo.rb` | Remove last exchange |
+| `/version` | `version.rb` | Show version info |
+
+## Action Hashes
+
+Some commands can't change REPL state directly (they don't have access to the loop
+or session). Instead, they return an **action hash** that the REPL processes:
+
+```ruby
+# Plan mode toggle
+{ action: :set_plan_mode, enabled: true }
+
+# Model switch
+{ action: :set_model, model: 'claude-sonnet-4-20250514' }
+
+# Budget update
+{ action: :set_budget, amount: 10.0 }
+
+# Spawn teammate
+{ action: :spawn_teammate, name: 'alice', role: 'coder' }
+
+# Resume session
+{ action: :set_session_id, session_id: 'abc123' }
+```
+
+The REPL's `handle_command` method pattern-matches on these and applies the state change.
+
+## Adding a New Command
+
+1. Create `lib/rubyn_code/cli/commands/my_command.rb`
+2. Inherit from `Base`, define `command_name` (with `/` prefix), `description`, `execute`
+3. Add autoload entry in `lib/rubyn_code.rb` under `module Commands`
+4. Register it in `REPL#setup_command_registry!`
+5. Add spec in `spec/rubyn_code/cli/commands/my_command_spec.rb`
+
+```ruby
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      class MyCommand < Base
+        def self.command_name = '/mycommand'
+        def self.description = 'Does a thing'
+
+        def execute(args, ctx)
+          ctx.renderer.info('Did the thing!')
+        end
+      end
+    end
+  end
+end
+```
+
+## Plan Mode
+
+`/plan` toggles plan mode via an action hash. When enabled:
+
+- `Agent::Loop` sends only **read-only tools** (risk level `:read`) to Claude
+- Claude can read files, grep, glob, check git status/log/diff — full exploration
+- Claude **cannot** write, edit, execute, or modify anything
+- A plan-mode system prompt is injected reinforcing these boundaries
+- Claude responds with analysis, proposed steps, and gathered context
+- Toggle off with `/plan` again to resume normal execution
+
+Read-only tools in plan mode: `read_file`, `grep`, `glob`, `git_diff`, `git_log`,
+`git_status`, `review_pr`, `memory_search`, `web_search`, `web_fetch`

data/lib/rubyn_code/cli/commands/base.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      # Abstract base class for all slash commands.
+      #
+      # Subclasses must implement:
+      #   - self.command_name  → String (e.g. '/doctor')
+      #   - self.description   → String (one-liner for /help)
+      #   - execute(args, ctx) → void
+      #
+      # Optionally override:
+      #   - self.aliases → Array<String> (e.g. ['/q', '/exit'])
+      #   - self.hidden? → Boolean (hide from /help listing)
+      class Base
+        class << self
+          def command_name
+            raise NotImplementedError, "#{name} must define self.command_name"
+          end
+
+          def description
+            raise NotImplementedError, "#{name} must define self.description"
+          end
+
+          def aliases
+            [].freeze
+          end
+
+          def hidden?
+            false
+          end
+
+          # All names this command responds to (primary + aliases).
+          #
+          # @return [Array<String>]
+          def all_names
+            [command_name, *aliases].freeze
+          end
+        end
+
+        # Execute the command.
+        #
+        # @param args [Array<String>] arguments passed after the command name
+        # @param ctx [Commands::Context] shared context with REPL dependencies
+        # @return [void]
+        def execute(args, ctx)
+          raise NotImplementedError, "#{self.class.name}#execute must be implemented"
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/cli/commands/budget.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      class Budget < Base
+        def self.command_name = '/budget'
+        def self.description = 'Show or set session budget (/budget [amount])'
+
+        def execute(args, ctx)
+          amount = args.first
+
+          if amount
+            ctx.renderer.info("Session budget set to $#{amount}")
+            { action: :set_budget, amount: amount.to_f }
+          else
+            remaining = ctx.budget_enforcer.remaining_budget
+            ctx.renderer.info("Remaining budget: $#{format('%.4f', remaining)}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/cli/commands/clear.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      class Clear < Base
+        def self.command_name = '/clear'
+        def self.description = 'Clear the terminal'
+
+        def execute(_args, _ctx)
+          system('clear')
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/cli/commands/compact.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      class Compact < Base
+        def self.command_name = '/compact'
+        def self.description = 'Compress conversation context'
+
+        def execute(args, ctx)
+          focus = args.first
+
+          compactor = ::RubynCode::Context::Compactor.new(llm_client: ctx.llm_client)
+          new_messages = compactor.manual_compact!(ctx.conversation.messages, focus: focus)
+          ctx.conversation.replace!(new_messages)
+          ctx.renderer.info("Context compacted. #{ctx.conversation.length} messages remaining.")
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/cli/commands/context.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      # Immutable context object passed to every slash command.
+      # Provides access to all REPL dependencies without coupling
+      # commands to the REPL class itself.
+      Context = Data.define(
+        :renderer,
+        :conversation,
+        :agent_loop,
+        :context_manager,
+        :budget_enforcer,
+        :llm_client,
+        :db,
+        :session_id,
+        :project_root,
+        :skill_loader,
+        :session_persistence,
+        :background_worker,
+        :permission_tier,
+        :plan_mode,
+        :message_handler
+      ) do
+        # Convenience: return a new Context with a message handler attached.
+        # Used by commands like /review that delegate to the LLM.
+        #
+        # @param handler [Proc] the REPL's handle_message proc
+        def with_message_handler(handler)
+          with(message_handler: handler)
+        end
+
+        # @param text [String] message to send through the agent loop
+        def send_message(text)
+          message_handler&.call(text)
+        end
+
+        # @return [Boolean]
+        def plan_mode? = plan_mode
+      end
+    end
+  end
+end