rubyn-code 0.1.0 → 0.2.0

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      class ContextInfo < Base
+        def self.command_name = '/context'
+        def self.description = 'Show context window usage'
+
+        CONTEXT_WINDOW = 200_000
+
+        def execute(_args, ctx)
+          stats = estimate_context(ctx)
+          render_context_bar(stats, ctx)
+        end
+
+        private
+
+        def estimate_context(ctx)
+          messages = ctx.conversation.messages
+          estimated = Observability::TokenCounter.estimate_messages(messages)
+          pct = ((estimated.to_f / CONTEXT_WINDOW) * 100).round(1)
+          { estimated: estimated, pct: pct, message_count: messages.size }
+        end
+
+        def render_context_bar(stats, ctx)
+          puts
+          puts "  Context: [#{progress_bar(stats[:pct])}] #{stats[:pct]}%"
+          puts "  #{fmt(stats[:estimated])} / #{fmt(CONTEXT_WINDOW)} tokens  •  #{stats[:message_count]} messages"
+          puts "  Model: #{Config::Defaults::DEFAULT_MODEL}#{plan_label(ctx)}"
+          puts
+        end
+
+        def progress_bar(pct, width: 30)
+          filled = [(pct / 100.0 * width).round, width].min
+          "#{bar_color(pct)}#{'█' * filled}\e[0m#{'░' * (width - filled)}"
+        end
+
+        def bar_color(pct)
+          return "\e[31m" if pct >= 80
+          return "\e[33m" if pct >= 50
+
+          "\e[32m"
+        end
+
+        def plan_label(ctx)
+          ctx.plan_mode? ? ' • 🧠 plan mode' : ''
+        end
+
+        def fmt(num)
+          num.to_s.reverse.gsub(/(\d{3})(?=\d)/, '\1,').reverse
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      class Cost < Base
+        def self.command_name = '/cost'
+        def self.description = 'Show token usage and costs'
+
+        def execute(_args, ctx)
+          ctx.renderer.cost_summary(
+            session_cost: ctx.budget_enforcer.session_cost,
+            daily_cost: ctx.budget_enforcer.daily_cost,
+            tokens: {
+              input: ctx.context_manager.total_input_tokens,
+              output: ctx.context_manager.total_output_tokens
+            }
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      class Diff < Base
+        def self.command_name = '/diff'
+        def self.description = 'Show git diff (staged, unstaged, or vs branch)'
+
+        def execute(args, ctx)
+          target = args.first || 'unstaged'
+
+          cmd = case target
+                when 'staged'   then 'git diff --cached'
+                when 'unstaged' then 'git diff'
+                else "git diff #{target}...HEAD"
+                end
+
+          output = `cd #{ctx.project_root} && #{cmd} 2>&1`
+
+          if output.strip.empty?
+            ctx.renderer.info("No changes (#{target}).")
+          else
+            puts output
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      class Doctor < Base
+        def self.command_name = '/doctor'
+        def self.description = 'Environment health check'
+
+        CHECKS = %i[
+          check_ruby
+          check_bundler
+          check_database
+          check_auth
+          check_skills
+          check_project
+        ].freeze
+
+        def execute(_args, ctx)
+          ctx.renderer.info('Rubyn Code Doctor 🩺')
+          puts
+
+          results = CHECKS.map { |check| send(check, ctx) }
+          results.each { |label, ok, detail| render_check(label, ok, detail) }
+
+          puts
+          render_summary(results, ctx.renderer)
+        end
+
+        private
+
+        def render_check(label, passed, detail)
+          icon = passed ? green('✓') : red('✗')
+          suffix = detail ? " — #{detail}" : ''
+          puts "  #{icon} #{label}#{suffix}"
+        end
+
+        def render_summary(results, renderer)
+          passed = results.count { |_, success, _| success }
+          failed = results.size - passed
+          summary = "#{passed} passed, #{failed} failed"
+
+          if failed.zero?
+            renderer.success("All checks passed! #{summary}")
+          else
+            renderer.warning("#{summary}. Fix the issues above.")
+          end
+        end
+
+        def check_ruby(_ctx)
+          version = RUBY_VERSION
+          ok = Gem::Version.new(version) >= Gem::Version.new('3.2')
+          ['Ruby version', ok, "#{version} (#{RUBY_PLATFORM})"]
+        end
+
+        def check_bundler(_ctx)
+          version = Gem.loaded_specs['bundler']&.version&.to_s || Bundler::VERSION
+          ['Bundler', true, "v#{version}"]
+        rescue StandardError
+          ['Bundler', false, 'not found']
+        end
+
+        def check_database(ctx)
+          db = ctx.db
+          count = db.query('SELECT COUNT(*) AS c FROM schema_migrations').first
+          migrations = count['c'] || count[:c]
+          ['Database', true, "#{migrations} migrations applied"]
+        rescue StandardError => e
+          ['Database', false, e.message]
+        end
+
+        def check_auth(_ctx)
+          if Auth::TokenStore.valid?
+            tokens = Auth::TokenStore.load
+            source = tokens&.fetch(:source, :unknown)
+            ['Authentication', true, source.to_s]
+          else
+            ['Authentication', false, 'no valid token found']
+          end
+        rescue StandardError => e
+          ['Authentication', false, e.message]
+        end
+
+        def check_skills(ctx)
+          catalog = ctx.skill_loader.catalog
+          count = catalog.list.size
+          ['Skills', count.positive?, "#{count} skills available"]
+        rescue StandardError => e
+          ['Skills', false, e.message]
+        end
+
+        def check_project(ctx)
+          gemfile = File.join(ctx.project_root, 'Gemfile')
+          return ['Project detected', false, 'no Gemfile found'] unless File.exist?(gemfile)
+
+          type = detect_project_type(ctx.project_root)
+          ['Project detected', true, "#{type} at #{ctx.project_root}"]
+        end
+
+        def detect_project_type(root)
+          return 'Rails' if File.exist?(File.join(root, 'config', 'application.rb'))
+          return 'Ruby' if File.exist?(File.join(root, 'Rakefile'))
+
+          'Ruby (Gemfile)'
+        end
+
+        def green(text)  = "\e[32m#{text}\e[0m"
+        def red(text)    = "\e[31m#{text}\e[0m"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      class Help < Base
+        def self.command_name = '/help'
+        def self.description = 'Show this help message'
+
+        def execute(_args, ctx)
+          ctx.renderer.info('Available commands:')
+          puts
+          render_commands(self.class.registry)
+          render_tips
+        end
+
+        private
+
+        def render_commands(registry)
+          registry.visible_commands.each do |cmd_class|
+            names = cmd_class.all_names.join(', ')
+            puts "  #{names.ljust(25)} #{cmd_class.description}"
+          end
+        end
+
+        def render_tips
+          puts
+          puts '  Tips:'
+          puts '    - Use @filename to include file contents in your message'
+          puts '    - End a line with \ for multiline input'
+          puts '    - Type / to list all commands'
+          puts
+        end
+
+        class << self
+          attr_accessor :registry
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      class Model < Base
+        def self.command_name = '/model'
+        def self.description = 'Show or switch model (/model [name])'
+
+        KNOWN_MODELS = %w[
+          claude-haiku-4-5
+          claude-sonnet-4-20250514
+          claude-opus-4-20250514
+        ].freeze
+
+        def execute(args, ctx)
+          name = args.first
+
+          if name
+            unless KNOWN_MODELS.include?(name)
+              ctx.renderer.warning("Unknown model: #{name}")
+              ctx.renderer.info("Known models: #{KNOWN_MODELS.join(', ')}")
+              return
+            end
+
+            ctx.renderer.info("Model switched to #{name}")
+            { action: :set_model, model: name }
+          else
+            current = Config::Defaults::DEFAULT_MODEL
+            ctx.renderer.info("Current model: #{current}")
+            ctx.renderer.info("Available: #{KNOWN_MODELS.join(', ')}")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      class Plan < Base
+        def self.command_name = '/plan'
+        def self.description = 'Toggle plan mode (think before acting)'
+
+        def execute(_args, ctx)
+          if ctx.plan_mode?
+            ctx.renderer.info('Plan mode OFF — back to full execution. 🚀')
+            { action: :set_plan_mode, enabled: false }
+          else
+            ctx.renderer.info("Plan mode ON — read-only tools only. I can explore but won't change anything. 🧠")
+            { action: :set_plan_mode, enabled: true }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      class Quit < Base
+        def self.command_name = '/quit'
+        def self.description = 'Exit Rubyn Code'
+        def self.aliases = ['/exit', '/q'].freeze
+
+        def execute(_args, _ctx)
+          :quit
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      # Discovers, registers, and dispatches slash commands.
+      #
+      # Commands are registered by class reference. The registry builds
+      # a lookup table from command names + aliases → command class.
+      class Registry
+        def initialize
+          @commands = {} # '/name' => CommandClass
+          @classes = []
+        end
+
+        # Register a command class.
+        #
+        # @param command_class [Class<Commands::Base>]
+        # @return [void]
+        def register(command_class)
+          @classes << command_class
+          command_class.all_names.each do |name|
+            @commands[name] = command_class
+          end
+        end
+
+        # Look up and execute a command by name.
+        #
+        # @param name [String] the slash command (e.g. '/doctor')
+        # @param args [Array<String>] arguments
+        # @param ctx [Commands::Context] shared context
+        # @return [Symbol, nil] :quit if the command signals exit, nil otherwise
+        def dispatch(name, args, ctx)
+          command_class = @commands[name]
+          return :unknown unless command_class
+
+          command_class.new.execute(args, ctx)
+        end
+
+        # All registered command names (for tab completion).
+        #
+        # @return [Array<String>]
+        def completions
+          @commands.keys.sort.freeze
+        end
+
+        # Visible commands for /help (excludes hidden commands).
+        #
+        # @return [Array<Class<Commands::Base>>] unique, sorted by name
+        def visible_commands
+          @classes
+            .reject(&:hidden?)
+            .sort_by(&:command_name)
+        end
+
+        # @param name [String]
+        # @return [Boolean]
+        def known?(name)
+          @commands.key?(name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      class Resume < Base
+        def self.command_name = '/resume'
+        def self.description = 'Resume a session or list recent sessions'
+
+        def execute(args, ctx)
+          session_id = args.first
+
+          if session_id
+            resume_session(session_id, ctx)
+          else
+            list_sessions(ctx)
+          end
+        end
+
+        private
+
+        def resume_session(session_id, ctx)
+          data = ctx.session_persistence.load_session(session_id)
+
+          if data
+            ctx.conversation.replace!(data[:messages])
+            ctx.renderer.info("Resumed session #{session_id[0..7]}")
+            { action: :set_session_id, session_id: session_id }
+          else
+            ctx.renderer.error("Session not found: #{session_id}")
+          end
+        end
+
+        def list_sessions(ctx)
+          sessions = ctx.session_persistence.list_sessions(
+            project_path: ctx.project_root,
+            limit: 10
+          )
+
+          if sessions.empty?
+            ctx.renderer.info('No previous sessions.')
+          else
+            sessions.each do |s|
+              puts "  #{s[:id][0..7]} | #{s[:title] || 'untitled'} | #{s[:created_at]}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      class Review < Base
+        def self.command_name = '/review'
+        def self.description = 'Review current branch against best practices'
+
+        def execute(args, ctx)
+          base = args.fetch(0, 'main')
+          focus = args.fetch(1, 'all')
+
+          ctx.send_message(build_prompt(base, focus))
+        end
+
+        private
+
+        def build_prompt(base, focus)
+          "Use the review_pr tool to review my current branch against #{base}. " \
+            "Focus: #{focus}. Load relevant best practice skills for any issues you find."
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      class Skill < Base
+        def self.command_name = '/skill'
+        def self.description = 'Load a skill or list available skills'
+
+        def execute(args, ctx)
+          args.first ? load_skill(args.first, ctx) : list_skills(ctx)
+        rescue StandardError => e
+          ctx.renderer.error("Skill error: #{e.message}")
+        end
+
+        private
+
+        def load_skill(name, ctx)
+          content = ctx.skill_loader.load(name)
+          ctx.renderer.info("Loaded skill: #{name}")
+          ctx.conversation.add_user_message("<skill>#{content}</skill>")
+        end
+
+        def list_skills(ctx)
+          skills = ctx.skill_loader.catalog.list
+          ctx.renderer.info("Available skills (#{skills.size}):")
+          skills.each { |skill| puts "  /#{skill}" }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      class Spawn < Base
+        def self.command_name = '/spawn'
+        def self.description = 'Spawn a teammate agent (/spawn <name> [role])'
+
+        def execute(args, ctx)
+          name = args[0]
+          unless name
+            ctx.renderer.error('Usage: /spawn <name> [role]')
+            return
+          end
+
+          role = args[1] || 'coder'
+
+          { action: :spawn_teammate, name: name, role: role }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      class Tasks < Base
+        def self.command_name = '/tasks'
+        def self.description = 'List all tasks'
+
+        STATUS_COLORS = {
+          'completed' => :green,
+          'in_progress' => :yellow,
+          'blocked' => :red
+        }.freeze
+
+        def execute(_args, ctx)
+          task_manager = ::RubynCode::Tasks::Manager.new(ctx.db)
+          tasks = task_manager.list
+
+          if tasks.empty?
+            ctx.renderer.info('No tasks.')
+            return
+          end
+
+          tasks.each do |t|
+            puts "  [#{t[:status]}] #{t[:title]} (#{t[:id][0..7]})"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      class Tokens < Base
+        def self.command_name = '/tokens'
+        def self.description = 'Show token usage and context window estimate'
+
+        # Claude's context window
+        CONTEXT_WINDOW = 200_000
+
+        TokenStats = Data.define(:estimated, :threshold, :actual_in, :actual_out, :message_count) do
+          def pct_window = ((estimated.to_f / CONTEXT_WINDOW) * 100).round(1)
+          def pct_threshold = ((estimated.to_f / threshold) * 100).round(1)
+          def total = actual_in + actual_out
+        end
+
+        def execute(_args, ctx)
+          stats = gather_stats(ctx)
+          render_estimation(stats)
+          render_actual_usage(stats)
+          warn_if_near_threshold(stats, ctx.renderer)
+        end
+
+        private
+
+        def gather_stats(ctx)
+          mgr = ctx.context_manager
+          estimated = Observability::TokenCounter.estimate_messages(ctx.conversation.messages)
+          threshold = mgr.instance_variable_get(:@threshold) || 50_000
+
+          TokenStats.new(
+            estimated: estimated, threshold: threshold,
+            actual_in: mgr.total_input_tokens,
+            actual_out: mgr.total_output_tokens,
+            message_count: ctx.conversation.messages.size
+          )
+        end
+
+        def render_estimation(stats)
+          puts
+          puts "  #{bold('Token Estimation')}"
+          puts "  #{dim('─' * 40)}"
+          puts "  Context estimate:  #{fmt(stats.estimated)} tokens " \
+               "(~#{stats.pct_window}% of #{fmt(CONTEXT_WINDOW)} window)"
+          puts "  Compaction at:     #{fmt(stats.threshold)} tokens (#{stats.pct_threshold}% used)"
+          puts "  Messages:          #{stats.message_count}"
+        end
+
+        def render_actual_usage(stats)
+          puts
+          puts "  #{bold('Actual Usage (this session)')}"
+          puts "  #{dim('─' * 40)}"
+          puts "  Input tokens:      #{fmt(stats.actual_in)}"
+          puts "  Output tokens:     #{fmt(stats.actual_out)}"
+          puts "  Total:             #{fmt(stats.total)}"
+          puts
+        end
+
+        def warn_if_near_threshold(stats, renderer)
+          return unless stats.pct_threshold >= 80
+
+          renderer.warning('⚠ Context nearing compaction threshold. Consider /compact.')
+        end
+
+        def bold(text) = "\e[1m#{text}\e[0m"
+        def dim(text)  = "\e[2m#{text}\e[0m"
+
+        def fmt(num)
+          num.to_s.reverse.gsub(/(\d{3})(?=\d)/, '\1,').reverse
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      class Undo < Base
+        def self.command_name = '/undo'
+        def self.description = 'Remove last exchange'
+
+        def execute(_args, ctx)
+          ctx.conversation.undo_last!
+          ctx.renderer.info('Last exchange removed.')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      class Version < Base
+        def self.command_name = '/version'
+        def self.description = 'Show version info'
+
+        def execute(_args, ctx)
+          ctx.renderer.info("Rubyn Code v#{RubynCode::VERSION}")
+        end
+      end
+    end
+  end
+end