rubyn-code 0.5.1 → 0.8.0

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      # Set or clear the reasoning effort level (output_config.effort).
+      #
+      #   /effort             # show current value
+      #   /effort off         # clear back to model default
+      #   /effort <level>     # low | medium | high | xhigh | max
+      class Effort < Base
+        LEVELS = %w[low medium high xhigh max].freeze
+
+        def self.command_name = '/effort'
+        def self.description = 'Set reasoning effort (low/medium/high/xhigh/max)'
+
+        def execute(args, ctx)
+          arg = args.first
+
+          current = ctx.llm_client.respond_to?(:effort) ? ctx.llm_client.effort : nil
+
+          case arg
+          when nil
+            show_status(current, ctx)
+          when 'off'
+            ctx.llm_client.effort = nil
+            ctx.renderer.info('Reasoning effort cleared — using model default 🎚️')
+          when *LEVELS
+            ctx.llm_client.effort = arg
+            ctx.renderer.info("Reasoning effort set to #{arg} 🎚️")
+          else
+            ctx.renderer.warning("Usage: /effort [off|#{LEVELS.join('|')}]. Got: #{arg}")
+          end
+        end
+
+        private
+
+        def show_status(current, ctx)
+          state = current || 'not set (model default: high on 4.6+)'
+          ctx.renderer.info("Reasoning effort: #{state}")
+          ctx.renderer.info("Usage: /effort <level>  levels: #{LEVELS.join(', ')}   (or /effort off)")
+          ctx.renderer.info('Supported on Claude 4.6+ models; xhigh requires Opus 4.7+ / Sonnet 5 / Fable 5.')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'json'
+
+module RubynCode
+  module CLI
+    module Commands
+      # Export the current conversation transcript to a file.
+      #
+      #   /export path/to/transcript.md              # markdown (default)
+      #   /export --format jsonl path/to/transcript.jsonl
+      #   /export path/to/transcript.md --force      # overwrite existing
+      class Export < Base
+        def self.command_name = '/export'
+        def self.description = 'Export conversation transcript to markdown or JSONL'
+
+        MAX_LINE_LENGTH = 100
+
+        # -- CLI arg parsing is intrinsically procedural
+        def execute(args, ctx)
+          opts = parse_args(args)
+          return unless opts
+
+          messages = ctx.conversation.to_a
+          if messages.empty?
+            ctx.renderer.warning('No messages to export.')
+            return
+          end
+
+          path = File.expand_path(opts[:path])
+          dir  = File.dirname(path)
+          FileUtils.mkdir_p(dir) unless File.directory?(dir)
+
+          if File.exist?(path) && !opts[:force] && !tty_yes?(ctx, "File exists at #{path}. Overwrite? [y/N]")
+            ctx.renderer.info('Export cancelled.')
+            return
+          end
+
+          body = opts[:format] == 'jsonl' ? render_jsonl(messages) : render_markdown(messages)
+          File.write(path, body)
+          plural = messages.size == 1 ? '' : 's'
+          ctx.renderer.info("Exported #{messages.size} message#{plural} to #{path}")
+        end
+
+        private
+
+        # @return [Hash{Symbol=>Object}, nil] nil on bad input
+        # -- arg parsing is intrinsically branchy
+        def parse_args(args) # rubocop:disable Metrics/MethodLength -- arg parsing is intrinsically procedural
+          format = 'markdown'
+          force  = false
+          path   = nil
+
+          if (idx = args.index('--format') || args.index('-f'))
+            format = args[idx + 1].to_s
+          end
+          format = case format
+                   when 'md' then 'markdown'
+                   else format
+                   end
+
+          args.each do |a|
+            case a
+            when '--jsonl'
+              format = 'jsonl'
+            when '--markdown', '--md'
+              format = 'markdown'
+            when '--format', '-f'
+              # already handled above
+            when '--force', '-y'
+              force = true
+            when /\A--.+/
+              next
+            else
+              path ||= a
+            end
+          end
+
+          return nil if path.to_s.empty?
+
+          { path: path, format: format, force: force }
+        end
+
+        def render_markdown(messages)
+          title  = 'Rubyn transcript'
+          buffer = String.new
+          buffer << "# #{title}\n\n"
+          buffer << "_Exported at #{Time.now.strftime('%Y-%m-%d %H:%M:%S')}_\n\n"
+          messages.each { |msg| render_markdown_message(buffer, msg) }
+          buffer
+        end
+
+        def render_markdown_message(buffer, msg)
+          role = msg[:role] || msg['role']
+          case role
+          when 'user'
+            text = render_user_text(msg[:content] || msg['content'])
+            buffer << "## User\n\n#{text}\n\n"
+          when 'assistant'
+            render_assistant_blocks(buffer, msg[:content] || msg['content'])
+          when 'tool'
+            buffer << "### tool result\n\n```\n#{msg[:content] || msg['content']}\n```\n\n"
+          end
+        end
+
+        def render_user_text(content)
+          blocks = normalize_content(content)
+          if blocks.any? { |b| block_type(b) == 'image' }
+            blocks.map { |b| block_type(b) == 'image' ? '_(image attachment)_' : text_of(b) }.join("\n")
+          else
+            blocks.map { |b| text_of(b) }.join("\n")
+          end
+        end
+
+        def render_assistant_blocks(buffer, content)
+          blocks = normalize_content(content)
+          if blocks.empty?
+            buffer << "## Assistant\n\n_(empty response)_\n\n"
+            return
+          end
+          blocks.each do |b|
+            render_assistant_block(buffer, b)
+          end
+        end
+
+        def render_assistant_block(buffer, b) # rubocop:disable Naming/MethodParameterName -- short names are clearer here than "block"
+          case block_type(b)
+          when 'text'
+            buffer << "## Assistant\n\n#{text_of(b)}\n\n"
+          when 'thinking'
+            buffer << "<details><summary>thinking</summary>\n\n#{text_of(b)}\n\n</details>\n\n"
+          when 'tool_use'
+            buffer << "[tool: #{b[:name] || b['name']}]\n\n```json\n#{JSON.pretty_generate(input_of(b))}\n```\n\n"
+          end
+        end
+
+        def render_jsonl(messages)
+          lines = messages.map do |msg|
+            role    = msg[:role] || msg['role']
+            raw     = msg[:content] || msg['content']
+            content = raw.is_a?(String) ? raw : normalize_content(raw)
+            "#{JSON.generate(role: role, content: content, timestamp: Time.now.utc.iso8601)}\n"
+          end
+          lines.join
+        end
+
+        # Wrap a String content into a single text block so we can render uniformly.
+        def normalize_content(content)
+          return [{ type: 'text', text: content.to_s }] if content.is_a?(String)
+          return [{ type: 'text', text: '' }] if content.nil?
+
+          content
+        end
+
+        def block_type(block)
+          block[:type] || block['type']
+        end
+
+        def text_of(block)
+          (block[:text] || block['text']).to_s
+        end
+
+        def input_of(block)
+          (block[:input] || block['input']) || {}
+        end
+
+        def tty_yes?(ctx, prompt)
+          ctx.renderer.respond_to?(:ask) ? ctx.renderer.ask(prompt, default: false) : true
+        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

@@ -8,46 +8,83 @@ module RubynCode
         def self.description = 'MCP server status'
 
         def execute(_args, ctx)
-          configs = load_configs(ctx.project_root)
+          entries = load_entries(ctx.project_root)
 
-          if configs.empty?
+          if entries.empty?
             ctx.renderer.info('No MCP servers configured.')
             puts '  Add servers to .rubyn-code/mcp.json — see docs/MCP.md for details.'
             return
           end
 
-          ctx.renderer.info("MCP servers (#{configs.size}):")
+          ctx.renderer.info("MCP servers (#{entries.size}):")
           puts
 
-          configs.each { |cfg| render_server(cfg) }
+          entries.each { |entry| render_server(entry) }
         end
 
         private
 
-        def load_configs(project_root)
-          MCP::Config.load(project_root)
+        # Load merged user + project entries via MCP::Discovery so the
+        # output can show which servers came from `~/.rubyn-code/mcp.json`
+        # vs the project-root `.mcp.json`.
+        def load_entries(project_root)
+          MCP::Discovery.discover(project_root)
         end
 
-        def render_server(cfg)
+        def source_label(source)
+          case source
+          when :project then '[project]'
+          when :user    then '[user]'
+          else               '[-]'
+          end
+        end
+
+        def render_server(entry)
+          cfg = entry_to_config(entry)
           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)" : ''
+          label = source_label(entry.respond_to?(:source) ? entry.source : :user)
 
-          puts "  #{icon} #{cfg[:name]} [#{status}]#{tools_label}"
+          puts "  #{icon} #{entry.name} #{label} [#{status}]#{capability_label(counts)}"
           render_transport_info(cfg)
         ensure
           client&.disconnect! if client&.connected?
         end
 
+        # Discovery::Entry → Config hash shape so existing renderers work.
+        def entry_to_config(entry)
+          {
+            name: entry.name,
+            command: entry.command,
+            args: entry.args,
+            env: entry.env,
+            url: entry.url
+          }
+        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).