rubyn-code 0.5.1 → 0.7.0

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      # `/chisel-review` — audit the current branch's changes for
+      # over-engineering and report a ranked deletion list. Read-only.
+      class ChiselReview < Base
+        def self.command_name = '/chisel-review'
+        def self.description = 'Find over-engineering in the current diff (/chisel-review [base])'
+
+        def execute(args, ctx)
+          # Inspection owns the 'main' default so it lives in exactly one place.
+          ctx.send_message(RubynCode::Chisel::Inspection.prompt(scope: :diff, target: args.first))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+module RubynCode
+  module CLI
+    module Commands
+      # Renders a user-defined slash-command body into a prompt, mirroring
+      # Claude Code's command templating:
+      #
+      #   $ARGUMENTS   → all args, space-joined
+      #   $1 .. $9     → positional args
+      #   !`shell cmd` → replaced with the command's (combined) output
+      #
+      # Bash substitution runs the user's own command file, so it carries the
+      # same trust as user hooks. Output is captured defensively and capped.
+      class CommandTemplate
+        BANG = /!`([^`]+)`/
+        POSITIONAL = /\$([1-9])/
+        MAX_BASH_OUTPUT = 16 * 1024
+
+        def initialize(body)
+          @body = body.to_s
+        end
+
+        # @param args [Array<String>] arguments passed after the command name
+        # @return [String] the rendered prompt
+        def render(args = [])
+          text = substitute_bash(@body)
+          text = text.gsub('$ARGUMENTS', args.join(' '))
+          text.gsub(POSITIONAL) { args[Regexp.last_match(1).to_i - 1].to_s }
+        end
+
+        private
+
+        def substitute_bash(text)
+          text.gsub(BANG) { run(Regexp.last_match(1)) }
+        end
+
+        def run(cmd)
+          out, = Open3.capture2e(cmd)
+          out = "#{out.byteslice(0, MAX_BASH_OUTPUT)}\n… [truncated]" if out.bytesize > MAX_BASH_OUTPUT
+          out.strip
+        rescue StandardError => e
+          "[command failed: #{e.message}]"
+        end
+      end
+    end
+  end
+end

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

@@ -21,7 +21,9 @@ module RubynCode
         :background_worker,
         :permission_tier,
         :plan_mode,
-        :message_handler
+        :message_handler,
+        :hook_registry,
+        :checkpoint_manager
       ) do
         # Convenience: return a new Context with a message handler attached.
         # Used by commands like /review that delegate to the LLM.

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      # A slash command defined by a user markdown file (loaded by
+      # CustomLoader). Unlike the built-in commands — which are registered as
+      # classes — this is a ready instance: the Registry dispatches it directly.
+      #
+      # Executing it renders the template (argument / bash substitution) and
+      # sends the result to the agent as a normal prompt.
+      class CustomCommand
+        # @return [String] command name without the leading slash
+        attr_reader :name
+        # @return [String] one-line description for /help
+        attr_reader :description
+        # @return [String, nil] originating file path
+        attr_reader :source
+
+        def initialize(name:, description:, body:, source: nil)
+          @name = name
+          @description = description
+          @template = CommandTemplate.new(body)
+          @source = source
+        end
+
+        def command_name = "/#{@name}"
+        def aliases = [].freeze
+        def hidden? = false
+        def all_names = [command_name].freeze
+
+        # @param args [Array<String>]
+        # @param ctx [Commands::Context]
+        # @return [nil]
+        def execute(args, ctx)
+          ctx.send_message(@template.render(args))
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module RubynCode
+  module CLI
+    module Commands
+      # Discovers user-defined slash commands from markdown files, mirroring
+      # Claude Code's `.claude/commands/*.md`:
+      #
+      #   <project>/.rubyn-code/commands/*.md   (project-local, takes priority)
+      #   ~/.rubyn-code/commands/*.md           (user-global)
+      #
+      # Each `deploy.md` becomes `/deploy`. Optional YAML frontmatter supplies
+      # the `description`; otherwise the first non-empty line is used. The body
+      # is the prompt template (see CommandTemplate for substitutions).
+      module CustomLoader
+        FRONTMATTER = /\A---\s*\n(.+?\n)---\s*\n(.*)\z/m
+        NAME = /\A[a-z0-9][a-z0-9_-]*\z/i
+
+        class << self
+          # @return [Array<CustomCommand>] unique commands (project overrides user)
+          def load_all(project_root:, home_dir: Config::Defaults::HOME_DIR)
+            dirs = [
+              project_root && File.join(project_root, '.rubyn-code', 'commands'),
+              File.join(home_dir, 'commands')
+            ].compact
+            dirs.flat_map { |dir| load_dir(dir) }.uniq(&:command_name)
+          end
+
+          def load_dir(dir)
+            return [] unless Dir.exist?(dir)
+
+            Dir.glob(File.join(dir, '*.md')).filter_map { |path| build(path) }
+          end
+
+          private
+
+          def build(path)
+            name = File.basename(path, '.md').strip
+            return nil unless name.match?(NAME)
+
+            description, body = parse(File.read(path))
+            description = "Custom command: /#{name}" if description.to_s.strip.empty?
+            CustomCommand.new(name: name, description: description, body: body, source: path)
+          rescue StandardError => e
+            RubynCode::Debug.warn("Failed to load custom command #{path}: #{e.message}")
+            nil
+          end
+
+          def parse(content)
+            if (match = FRONTMATTER.match(content))
+              frontmatter = YAML.safe_load(match[1]) || {}
+              [frontmatter['description'].to_s, match[2].to_s.strip]
+            else
+              body = content.to_s.strip
+              [first_line(body), body]
+            end
+          end
+
+          def first_line(body)
+            line = body.lines.first.to_s.strip
+            line.sub(/\A#+\s*/, '')[0, 80]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      # `/goal` — set a session goal that Rubyn keeps working toward until it
+      # is met. Installs a Stop hook (Hooks::GoalHook) that blocks the agent
+      # from finishing while the goal is unmet; the goal auto-clears once an
+      # evaluator judges it satisfied.
+      #
+      #   /goal <condition>   set a goal and start working toward it
+      #   /goal               show the current goal (if any)
+      #   /goal clear         cancel the active goal early
+      class Goal < Base
+        def self.command_name = '/goal'
+        def self.description  = 'Set a goal Rubyn works toward until met (/goal clear to cancel)'
+
+        CLEAR_WORDS = %w[clear cancel off stop].freeze
+
+        def execute(args, ctx)
+          first = args.first&.strip&.downcase
+          return clear_goal(ctx) if CLEAR_WORDS.include?(first)
+
+          condition = args.join(' ').strip
+          return show_status(ctx) if condition.empty?
+
+          set_goal(ctx, condition)
+        end
+
+        private
+
+        def set_goal(ctx, condition)
+          deactivate_existing(ctx)
+          evaluator = RubynCode::Goal::Evaluator.new(llm_client: ctx.llm_client)
+          ctx.hook_registry.on(:stop, Hooks::GoalHook.new(condition: condition, evaluator: evaluator), priority: 10)
+
+          ctx.renderer.info("🎯 Goal set: #{condition}")
+          ctx.renderer.info("Rubyn will keep working until it's met. /goal clear to cancel.")
+          ctx.send_message(kickoff_prompt(condition))
+          nil
+        end
+
+        def clear_goal(ctx)
+          if deactivate_existing(ctx).positive?
+            ctx.renderer.info('Goal cleared. ✌️')
+          else
+            ctx.renderer.info('No active goal to clear.')
+          end
+          nil
+        end
+
+        def show_status(ctx)
+          active = active_goals(ctx)
+          if active.empty?
+            ctx.renderer.info('No active goal. Set one with: /goal <what you want done>')
+          else
+            ctx.renderer.info("🎯 Active goal: #{active.first.condition}")
+          end
+          nil
+        end
+
+        # Deactivate any active GoalHook(s) on the registry.
+        # @return [Integer] number of goals deactivated
+        def deactivate_existing(ctx)
+          active_goals(ctx).each(&:clear!).size
+        end
+
+        def active_goals(ctx)
+          return [] unless ctx.hook_registry
+
+          ctx.hook_registry.hooks_for(:stop).select do |hook|
+            hook.is_a?(Hooks::GoalHook) && hook.active?
+          end
+        end
+
+        def kickoff_prompt(condition)
+          <<~PROMPT.strip
+            New session goal: #{condition}
+
+            Start working toward this goal now. Keep going until it is genuinely
+            met — don't stop to ask what to do next.
+          PROMPT
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      # `/learning` — inspect and move the instincts Rubyn learns across
+      # sessions. Continuous learning runs automatically at the end of each
+      # session; this command lets you carry those learnings to another machine.
+      #
+      #   /learning                       show learning stats
+      #   /learning export [path]         export all instincts to a JSON file
+      #   /learning import <path> [--here] import instincts (--here = remap to this project)
+      class Learning < Base
+        def self.command_name = '/learning'
+        def self.description  = 'Show, export, or import learned instincts (/learning export|import)'
+
+        DEFAULT_FILE = 'rubyn-learnings.json'
+
+        def execute(args, ctx)
+          case args.first
+          when 'export' then export(ctx, args[1])
+          when 'import' then import(ctx, args[1..])
+          when nil      then stats(ctx)
+          else
+            ctx.renderer.info('Usage: /learning [export [path] | import <path> [--here]]')
+          end
+          nil
+        rescue RubynCode::Learning::Porter::Error => e
+          ctx.renderer.error("Learning: #{e.message}")
+          nil
+        end
+
+        private
+
+        def stats(ctx)
+          summary = RubynCode::Learning::Porter.stats(ctx.db)
+          ctx.renderer.info("🧠 #{summary[:count]} instinct(s) learned across #{summary[:projects]} project(s).")
+          ctx.renderer.info('Move them with: /learning export  →  /learning import <file> --here')
+        end
+
+        def export(ctx, path)
+          dest = File.expand_path(path || DEFAULT_FILE, ctx.project_root)
+          count = RubynCode::Learning::Porter.export(db: ctx.db, path: dest)
+          ctx.renderer.info("📤 Exported #{count} instinct(s) to #{dest}")
+        end
+
+        def import(ctx, rest)
+          args = Array(rest)
+          here = args.delete('--here')
+          path = args.first
+          return ctx.renderer.info('Usage: /learning import <path> [--here]') unless path
+
+          remap = here ? ctx.project_root : nil
+          result = RubynCode::Learning::Porter.import(
+            db: ctx.db, path: File.expand_path(path, ctx.project_root), remap_project: remap
+          )
+          ctx.renderer.info("📥 Imported #{result[:imported]} instinct(s) (#{result[:skipped]} skipped as duplicates).")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      # `/loop` — run a prompt or slash command repeatedly, mirroring Claude
+      # Code's /loop. Either on a fixed interval, or self-paced (the agent
+      # decides when the recurring task is done).
+      #
+      #   /loop 5m /review            run /review every 5 minutes
+      #   /loop 30s check the deploy  send a prompt every 30 seconds
+      #   /loop x10 5m /babysit-prs   ...at most 10 times
+      #   /loop keep triaging issues  self-paced (until the agent emits LOOP_DONE)
+      #
+      # Returns a :run_loop action; the REPL owns the actual loop so Ctrl-C
+      # stops it cleanly and slash payloads can be re-dispatched.
+      class Loop < Base
+        def self.command_name = '/loop'
+        def self.description  = 'Repeat a prompt or slash command on an interval (/loop 5m /review)'
+
+        MAX_TOKEN = /\Ax(\d+)\z/i
+
+        def execute(args, ctx)
+          return usage(ctx) if args.empty?
+
+          max, rest = extract_max(args)
+          interval = LoopRunner.parse_interval(rest.first)
+          payload = (interval ? rest[1..] : rest).join(' ').strip
+          return usage(ctx) if payload.empty?
+
+          { action: :run_loop, interval: interval, max: max, payload: payload }
+        end
+
+        private
+
+        # Pull an optional leading "xN" max-iterations token from anywhere in
+        # the first two positions (so both `/loop x5 5m ...` and `/loop 5m ...`
+        # read naturally).
+        def extract_max(args)
+          idx = args[0, 2].index { |a| a.match?(MAX_TOKEN) }
+          return [LoopRunner::DEFAULT_MAX_ITERATIONS, args] unless idx
+
+          max = args[idx][MAX_TOKEN, 1].to_i
+          [max.positive? ? max : LoopRunner::DEFAULT_MAX_ITERATIONS, args[0...idx] + args[(idx + 1)..]]
+        end
+
+        def usage(ctx)
+          ctx.renderer.info('Usage: /loop [xN] [interval] <prompt-or-/command>')
+          ctx.renderer.info('  /loop 5m /review        — run /review every 5 minutes')
+          ctx.renderer.info('  /loop 30s check status  — send a prompt every 30s')
+          ctx.renderer.info('  /loop x3 1m /babysit    — at most 3 times')
+          ctx.renderer.info('  /loop keep triaging     — self-paced (Ctrl-C to stop)')
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -30,24 +30,37 @@ module RubynCode
 
         def render_server(cfg)
           client = build_client(cfg)
-          status, tool_count = probe_server(client)
+          status, counts = probe_server(client)
           icon = status_icon(status)
-          tools_label = tool_count ? " (#{tool_count} tools)" : ''
 
-          puts "  #{icon} #{cfg[:name]} [#{status}]#{tools_label}"
+          puts "  #{icon} #{cfg[:name]} [#{status}]#{capability_label(counts)}"
           render_transport_info(cfg)
         ensure
           client&.disconnect! if client&.connected?
         end
 
+        def capability_label(counts)
+          return '' unless counts
+
+          parts = []
+          parts << "#{counts[:tools]} tools"
+          parts << "#{counts[:resources]} resources" if counts[:resources].positive?
+          parts << "#{counts[:prompts]} prompts" if counts[:prompts].positive?
+          " (#{parts.join(', ')})"
+        end
+
         def build_client(cfg)
           MCP::Client.from_config(cfg)
         end
 
         def probe_server(client)
           client.connect!
-          tool_count = client.tools.size
-          [:connected, tool_count]
+          counts = {
+            tools: client.tools.size,
+            resources: client.resources.size,
+            prompts: client.prompts.size
+          }
+          [:connected, counts]
         rescue StandardError
           [:error, nil]
         end

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

@@ -1,4 +1,4 @@
-  # frozen_string_literal: true
+# frozen_string_literal: true
 
 module RubynCode
   module CLI

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

@@ -13,14 +13,16 @@ module RubynCode
           @classes = []
         end
 
-        # Register a command class.
+        # Register a command. Accepts either a command class (built-ins, which
+        # are instantiated per dispatch) or a ready command instance
+        # (user-defined; see Commands::CustomCommand).
         #
-        # @param command_class [Class<Commands::Base>]
+        # @param command [Class<Commands::Base>, #execute]
         # @return [void]
-        def register(command_class)
-          @classes << command_class
-          command_class.all_names.each do |name|
-            @commands[name] = command_class
+        def register(command)
+          @classes << command
+          command.all_names.each do |name|
+            @commands[name] = command
           end
         end
 
@@ -31,10 +33,13 @@ module RubynCode
         # @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 = @commands[name]
+          return :unknown unless command
 
-          command_class.new.execute(args, ctx)
+          # Built-ins are registered as classes (instantiate per call);
+          # user-defined commands are registered as ready instances.
+          instance = command.respond_to?(:new) ? command.new : command
+          instance.execute(args, ctx)
         end
 
         # All registered command names (for tab completion).

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      # `/rewind` — restore the session to an earlier checkpoint, mirroring
+      # Claude Code's /rewind. A checkpoint is taken at the start of each user
+      # turn, capturing the conversation and the original contents of any files
+      # changed that turn.
+      #
+      #   /rewind                list checkpoints
+      #   /rewind <id>           restore code + conversation to checkpoint <id>
+      #   /rewind <id> code      restore only the files
+      #   /rewind <id> chat      restore only the conversation
+      class Rewind < Base
+        def self.command_name = '/rewind'
+        def self.description  = 'Rewind to an earlier checkpoint (/rewind to list)'
+
+        SCOPES = { 'code' => :code, 'chat' => :chat, 'both' => :both }.freeze
+
+        def execute(args, ctx)
+          manager = ctx.checkpoint_manager
+          return ctx.renderer.info('Checkpoints are not available in this session.') unless manager
+
+          id = args.first
+          return list(manager, ctx) if id.nil?
+
+          restore(manager, ctx, id, args[1])
+        end
+
+        private
+
+        def list(manager, ctx)
+          checkpoints = manager.list
+          return ctx.renderer.info('No checkpoints yet — they are created as you work.') if checkpoints.empty?
+
+          ctx.renderer.info('Checkpoints (newest last):')
+          checkpoints.each do |cp|
+            puts "  #{cp[:id].to_s.rjust(3)}  #{cp[:files]} file(s)  — #{cp[:label]}"
+          end
+          puts
+          ctx.renderer.info('Restore with: /rewind <id> [code|chat]')
+          nil
+        end
+
+        def restore(manager, ctx, id_arg, scope_arg)
+          scope = SCOPES.fetch(scope_arg.to_s, :both)
+          result = manager.restore(id_arg.to_i, ctx.conversation, scope: scope)
+          return ctx.renderer.warning("No checkpoint ##{id_arg}.") unless result
+
+          ctx.renderer.info(restored_message(result, scope))
+          { action: :rewound }
+        end
+
+        def restored_message(result, scope)
+          case scope
+          when :code then "⏪ Restored #{result[:files_restored]} file(s) to checkpoint ##{result[:id]}."
+          when :chat then "⏪ Restored conversation to checkpoint ##{result[:id]}."
+          else "⏪ Rewound to checkpoint ##{result[:id]} (#{result[:files_restored]} file(s) + conversation)."
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/cli/first_run.rb

@@ -136,7 +136,7 @@ module RubynCode
       def default_model(provider)
         return 'gpt-5.4' if provider == 'openai'
 
-        'claude-opus-4-6'
+        'claude-opus-4-8'
       end
 
       def display_summary

data/lib/rubyn_code/cli/loop_runner.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    # Drives a repeating execution of a payload (a prompt or slash command).
+    #
+    # Pure orchestration with injected dependencies so it can be unit-tested
+    # without a REPL: the caller supplies a `runner` callable that performs one
+    # iteration and a `sleeper` for the wait between iterations.
+    #
+    # Two modes:
+    #   - interval mode (interval is a positive number of seconds): run, wait,
+    #     run, ... until max_iterations or stopped.
+    #   - self-paced mode (interval is nil): run back-to-back until the runner
+    #     returns :stop, emits the DONE_SENTINEL, or max_iterations is hit.
+    class LoopRunner
+      DEFAULT_MAX_ITERATIONS = 50
+      DONE_SENTINEL = 'LOOP_DONE'
+      UNITS = { 's' => 1, 'm' => 60, 'h' => 3600 }.freeze
+
+      # Parse an interval token like "30s", "5m", "2h", or a bare "45"
+      # (seconds). Returns nil when the token is not a valid interval.
+      #
+      # @param token [String, nil]
+      # @return [Integer, nil] seconds, or nil
+      def self.parse_interval(token)
+        return nil if token.nil?
+
+        match = token.strip.match(/\A(\d+)\s*([smh]?)\z/i)
+        return nil unless match
+
+        amount = match[1].to_i
+        return nil if amount <= 0
+
+        amount * UNITS.fetch(match[2].downcase, 1)
+      end
+
+      # @param interval [Integer, nil] seconds between runs; nil => self-paced
+      # @param runner [#call] ->(iteration_index) => String|:stop
+      # @param max_iterations [Integer] hard cap on iterations
+      # @param sleeper [#call, nil] ->(seconds); defaults to Kernel#sleep
+      # @param on_iteration [#call, nil] ->(n, total) UI callback before each run
+      def initialize(runner:, interval: nil, max_iterations: DEFAULT_MAX_ITERATIONS,
+                     sleeper: nil, on_iteration: nil)
+        @interval = interval
+        @runner = runner
+        @max_iterations = max_iterations
+        @sleeper = sleeper || ->(seconds) { sleep(seconds) }
+        @on_iteration = on_iteration
+        @stopped = false
+      end
+
+      # Request the loop to stop after the current iteration.
+      # @return [void]
+      def stop!
+        @stopped = true
+      end
+
+      # @return [Boolean]
+      def stopped? = @stopped
+
+      # Run the loop.
+      #
+      # @return [Integer] number of iterations completed
+      def run
+        completed = 0
+        @max_iterations.times do |index|
+          break if @stopped
+
+          @on_iteration&.call(index + 1, @max_iterations)
+          result = @runner.call(index)
+          completed += 1
+
+          break if @stopped || done?(result)
+
+          wait_before_next(index)
+        end
+        completed
+      rescue Interrupt
+        completed
+      end
+
+      private
+
+      def wait_before_next(index)
+        return unless @interval && index < @max_iterations - 1
+
+        @sleeper.call(@interval)
+      end
+
+      def done?(result)
+        return true if result == :stop
+
+        result.is_a?(String) && result.include?(DONE_SENTINEL)
+      end
+    end
+  end
+end