ruby_coded 0.3.1 → 0.4.0

data/lib/ruby_coded/chat/renderer/chat_panel_thinking.rb

@@ -68,7 +68,14 @@ module RubyCoded
         end
 
         def format_thinking_text(cycle_messages)
-          cycle_messages.map { |m| format_thinking_message(m) }.join("\n")
+          rich_text_plain(format_thinking_lines(cycle_messages))
+        end
+
+        def format_thinking_lines(cycle_messages)
+          cycle_messages.flat_map.with_index do |msg, index|
+            lines = format_thinking_message_rich(msg)
+            index == cycle_messages.length - 1 ? lines : lines + [@tui.line(spans: [@tui.span(content: "")])]
+          end
         end
 
         def format_thinking_message(msg)
@@ -82,41 +89,20 @@ module RubyCoded
           end
         end
 
-        def render_chat_with_thinking(frame, area, messages)
-          full_cycle = current_cycle_messages(messages)
-          cycle = tail_of_cycle(full_cycle)
-          prior = messages[0...(messages.length - full_cycle.length)]
-          chat_area, thinking_area = split_chat_thinking(area)
-
-          render_messages_in_area(frame, chat_area, prior)
-          render_thinking_panel(frame, thinking_area, format_thinking_text(cycle))
-        end
-
-        def split_chat_thinking(area)
-          @tui.layout_split(
-            area,
-            direction: :vertical,
-            constraints: [@tui.constraint_fill(3), @tui.constraint_fill(2)]
-          )
+        def format_thinking_message_rich(msg)
+          text, role = thinking_rich_text_and_role(msg)
+          rich_text_lines(text, role: role)
         end
 
-        def render_thinking_panel(frame, area, thinking_text)
-          scroll_y = thinking_scroll_y(area, thinking_text)
-
-          widget = @tui.paragraph(
-            text: thinking_text,
-            wrap: true,
-            scroll: [scroll_y, 0],
-            block: @tui.block(title: "thinking...", borders: [:all])
-          )
-          frame.render_widget(widget, area)
-        end
-
-        def thinking_scroll_y(area, text)
-          inner_height = [area.height - 2, 0].max
-          inner_width = [area.width - 2, 0].max
-          total_lines = count_wrapped_lines(text, inner_width)
-          [total_lines - inner_height, 0].max
+        def thinking_rich_text_and_role(msg)
+          case msg[:role]
+          when :assistant    then [msg[:content].gsub(%r{</?think>}, ""), :assistant]
+          when :tool_call    then [">> #{msg[:content]}", :tool_call]
+          when :tool_pending then ["?? #{msg[:content]}", :tool_pending]
+          when :tool_result  then ["   #{msg[:content]}", :tool_result]
+          when :system       then ["--- #{msg[:content]}", :system]
+          else                    [msg[:content].to_s, :assistant]
+          end
         end
       end
     end

data/lib/ruby_coded/chat/renderer/chat_panel_thinking_render.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RubyCoded
+  module Chat
+    class Renderer
+      # Layout and widget rendering for the split chat/thinking panel view.
+      module ChatPanelThinkingRender
+        private
+
+        def render_chat_with_thinking(frame, area, messages)
+          full_cycle = current_cycle_messages(messages)
+          cycle = tail_of_cycle(full_cycle)
+          prior = messages[0...(messages.length - full_cycle.length)]
+          chat_area, thinking_area = split_chat_thinking(area)
+
+          render_messages_in_area(frame, chat_area, prior)
+          render_thinking_panel(frame, thinking_area, format_thinking_lines(cycle))
+        end
+
+        def split_chat_thinking(area)
+          @tui.layout_split(
+            area,
+            direction: :vertical,
+            constraints: [@tui.constraint_fill(3), @tui.constraint_fill(2)]
+          )
+        end
+
+        def render_thinking_panel(frame, area, thinking_lines)
+          scroll_y = thinking_scroll_y(area, thinking_lines)
+
+          widget = @tui.paragraph(
+            text: thinking_lines,
+            wrap: true,
+            scroll: [scroll_y, 0],
+            block: @tui.block(title: "thinking...", borders: [:all])
+          )
+          frame.render_widget(widget, area)
+        end
+
+        def thinking_scroll_y(area, text_or_lines)
+          inner_height = [area.height - 2, 0].max
+          inner_width = [area.width - 2, 0].max
+          total_lines = count_wrapped_lines(text_or_lines, inner_width)
+          [total_lines - inner_height, 0].max
+        end
+      end
+    end
+  end
+end

data/lib/ruby_coded/chat/renderer/rich_text.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require_relative "rich_text_inline"
+
+module RubyCoded
+  module Chat
+    class Renderer
+      # Helpers for building and serializing rich text using ratatui text lines/spans.
+      module RichText
+        include RichTextInline
+
+        def rich_text_lines(text, role: :assistant)
+          return [] if text.nil? || text.empty?
+
+          parse_rich_text(text, role: role)
+        end
+
+        def rich_text_plain(lines)
+          Array(lines).map { |line| rich_line_plain(line) }.join("\n")
+        end
+
+        def rich_line_plain(line)
+          return line.to_s unless line.respond_to?(:spans)
+
+          Array(line.spans).map { |span| span.respond_to?(:content) ? span.content.to_s : span.to_s }.join
+        end
+
+        def parse_rich_text(text, role: :assistant)
+          state = { lines: [], in_code_block: false }
+          text.split("\n", -1).each { |raw_line| parse_rich_line(raw_line, state, role) }
+          state[:lines]
+        end
+
+        def parse_rich_line(raw_line, state, role)
+          return toggle_code_fence(raw_line, state) if raw_line.start_with?("```")
+
+          state[:lines] << rich_line_for(raw_line, state[:in_code_block], role)
+        end
+
+        def toggle_code_fence(raw_line, state)
+          if state[:in_code_block]
+            state[:in_code_block] = false
+            return
+          end
+
+          state[:in_code_block] = true
+          language = raw_line.delete_prefix("```").strip
+          state[:lines] << code_language_line(language) unless language.empty?
+        end
+
+        def rich_line_for(raw_line, in_code_block, role)
+          return @tui.line(spans: inline_spans(raw_line, role: role)) unless in_code_block
+
+          @tui.line(spans: [@tui.span(content: raw_line, style: code_block_style)])
+        end
+
+        def code_language_line(language)
+          @tui.line(spans: [@tui.span(content: "[#{language}]", style: @tui.style(fg: :yellow, modifiers: [:bold]))])
+        end
+
+        def merge_style(style, foreground: nil, background: nil, modifiers: [])
+          @tui.style(
+            fg: foreground || style&.fg,
+            bg: background || style&.bg,
+            modifiers: ((style&.modifiers || []) + modifiers).uniq
+          )
+        end
+
+        BASE_TEXT_STYLES = {
+          system: { fg: :dark_gray, modifiers: [:italic] },
+          user_label: { fg: :cyan, modifiers: [:bold] },
+          tool_call: { fg: :yellow, modifiers: [:bold] },
+          tool_pending: { fg: :magenta, modifiers: [:bold] },
+          tool_result: { fg: :green },
+          thinking_title: { fg: :blue, modifiers: [:bold] }
+        }.freeze
+
+        def base_text_style(role)
+          @tui.style(**BASE_TEXT_STYLES.fetch(role, { modifiers: [] }))
+        end
+
+        def inline_code_style
+          @tui.style(fg: :yellow, bg: :dark_gray)
+        end
+
+        def code_block_style
+          @tui.style(fg: :green, bg: :black)
+        end
+      end
+    end
+  end
+end

data/lib/ruby_coded/chat/renderer/rich_text_inline.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module RubyCoded
+  module Chat
+    class Renderer
+      # Inline markdown parsing (code, bold, italic) into ratatui spans.
+      module RichTextInline
+        def inline_spans(text, role: :assistant)
+          spans = []
+          remaining = text.dup
+
+          while !remaining.empty?
+            marker, index = next_inline_marker(remaining)
+            unless marker
+              spans << @tui.span(content: remaining, style: base_text_style(role))
+              break
+            end
+
+            prefix = remaining[0...index]
+            spans << @tui.span(content: prefix, style: base_text_style(role)) unless prefix.empty?
+
+            consumed = append_styled_span!(spans, remaining[index..], role: role)
+            if consumed
+              remaining = remaining[(index + consumed)..]
+            else
+              spans << @tui.span(content: remaining[index], style: base_text_style(role))
+              remaining = remaining[(index + 1)..]
+            end
+          end
+
+          spans = [@tui.span(content: "", style: base_text_style(role))] if spans.empty?
+          spans
+        end
+
+        def next_inline_marker(text)
+          markers = ["`", "**", "*"]
+          positions = markers.filter_map do |marker|
+            index = text.index(marker)
+            [marker, index] if index
+          end
+          positions.min_by { |(_, index)| index }
+        end
+
+        def append_styled_span!(spans, text, role: :assistant)
+          return append_code_span!(spans, text) if text.start_with?("`")
+          return append_bold_span!(spans, text, role: role) if text.start_with?("**")
+          return append_italic_span!(spans, text, role: role) if text.start_with?("*")
+
+          nil
+        end
+
+        def append_code_span!(spans, text)
+          close = text.index("`", 1)
+          return nil unless close
+
+          content = text[1...close]
+          spans << @tui.span(content: content, style: inline_code_style)
+          close + 1
+        end
+
+        def append_bold_span!(spans, text, role: :assistant)
+          close = text.index("**", 2)
+          return nil unless close
+
+          content = text[2...close]
+          spans << @tui.span(content: content, style: merge_style(base_text_style(role), modifiers: [:bold]))
+          close + 2
+        end
+
+        def append_italic_span!(spans, text, role: :assistant)
+          close = text.index("*", 1)
+          return nil unless close
+
+          content = text[1...close]
+          spans << @tui.span(content: content, style: merge_style(base_text_style(role), modifiers: [:italic]))
+          close + 1
+        end
+      end
+    end
+  end
+end

data/lib/ruby_coded/chat/renderer.rb

@@ -1,7 +1,13 @@
 # frozen_string_literal: true
 
+require_relative "renderer/rich_text"
+require_relative "renderer/chat_panel_formatting"
+require_relative "renderer/chat_panel_sections"
+require_relative "renderer/chat_panel_layout"
+require_relative "renderer/chat_panel_cache"
 require_relative "renderer/chat_panel"
 require_relative "renderer/chat_panel_thinking"
+require_relative "renderer/chat_panel_thinking_render"
 require_relative "renderer/chat_panel_input"
 require_relative "renderer/model_selector"
 require_relative "renderer/plan_clarifier_layout"
@@ -14,8 +20,14 @@ module RubyCoded
   module Chat
     # This class manages the rendering of the UI elements
     class Renderer
+      include RichText
+      include ChatPanelFormatting
+      include ChatPanelSections
+      include ChatPanelLayout
+      include ChatPanelCache
       include ChatPanel
       include ChatPanelThinking
+      include ChatPanelThinkingRender
       include ChatPanelInput
       include ModelSelector
       include PlanClarifierLayout

data/lib/ruby_coded/chat/runtime_mode.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module RubyCoded
+  module Chat
+    # Value object representing the runtime mode of the assistant.
+    #
+    # Modes are the single source of truth for tool availability,
+    # prompt selection, mutation permission, and confirmation policy.
+    # Bridges hold a RuntimeMode instance instead of independent
+    # boolean flags to avoid inconsistent combinations.
+    class RuntimeMode
+      NAMES = %i[chat agent plan].freeze
+
+      attr_reader :name
+
+      def initialize(name)
+        raise ArgumentError, "unknown mode: #{name.inspect}" unless NAMES.include?(name)
+
+        @name = name
+      end
+
+      def chat?
+        @name == :chat
+      end
+
+      def agent?
+        @name == :agent
+      end
+
+      def plan?
+        @name == :plan
+      end
+
+      # Tools may be invoked in this mode (readonly for plan, full for agent).
+      def allows_tools?
+        agent? || plan?
+      end
+
+      # Destructive/write tools are permitted only in agent mode.
+      def allows_mutation?
+        agent?
+      end
+
+      # User confirmation is required for non-safe tools outside chat mode.
+      def requires_confirmation?
+        agent? || plan?
+      end
+
+      # Symbol used when querying skills for this mode.
+      def skill_mode
+        @name
+      end
+
+      def to_s
+        @name.to_s
+      end
+
+      def ==(other)
+        other.is_a?(RuntimeMode) && other.name == @name
+      end
+      alias eql? ==
+
+      def hash
+        [self.class, @name].hash
+      end
+
+      CHAT = new(:chat)
+      AGENT = new(:agent)
+      PLAN = new(:plan)
+
+      class << self
+        def chat
+          CHAT
+        end
+
+        def agent
+          AGENT
+        end
+
+        def plan
+          PLAN
+        end
+
+        def for(value)
+          return value if value.is_a?(RuntimeMode)
+
+          case value.to_sym
+          when :chat then CHAT
+          when :agent then AGENT
+          when :plan then PLAN
+          else raise ArgumentError, "unknown mode: #{value.inspect}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_coded/commands/core_provider.rb

@@ -83,6 +83,13 @@ module RubyCoded
           handler: :cmd_commands,
           source: :core,
           usage: "/commands [reload|list]"
+        },
+        {
+          name: "/skills",
+          description: "Manage project-local skills",
+          handler: :cmd_skills,
+          source: :core,
+          usage: "/skills [reload|list]"
         }
       ].freeze
 

data/lib/ruby_coded/commands.rb

@@ -1,5 +1,16 @@
 # frozen_string_literal: true
 
+# Commands are **explicit user-invoked actions**.
+#
+# Every command is triggered by the user typing a leading slash
+# (e.g. `/agent`, `/plan`, `/model`, `/help`, or a project-local
+# markdown command like `/review-auth`). Commands are dispatched by
+# CommandHandler and never fire automatically.
+#
+# See also:
+# - RubyCoded::Skills   — automatic prompt overlays (no user typing).
+# - RubyCoded::Plugins  — code-level behavioral extensions.
+
 require_relative "commands/command_definition"
 require_relative "commands/core_provider"
 require_relative "commands/plugin_provider"

data/lib/ruby_coded/plugins.rb

@@ -1,5 +1,15 @@
 # frozen_string_literal: true
 
+# Plugins are **code-level behavioral extensions** to the chat runtime.
+#
+# A plugin can extend State, InputHandler, Renderer, or CommandHandler
+# through `apply_extensions!`. Plugins may register their own slash
+# commands, but they may also add invisible behavior (e.g. command
+# completion). Contrast with:
+#
+# - RubyCoded::Commands — explicit user-invoked slash actions.
+# - RubyCoded::Skills   — automatic prompt overlays for the model.
+
 require_relative "plugins/base"
 require_relative "plugins/registry"
 
@@ -17,5 +27,4 @@ end
 
 require_relative "plugins/command_completion/plugin"
 
-# Register built-in plugins
 RubyCoded.register_plugin(RubyCoded::Plugins::CommandCompletion::Plugin)

data/lib/ruby_coded/skills/catalog.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require_relative "skill_definition"
+require_relative "markdown_loader"
+
+module RubyCoded
+  module Skills
+    # Loads, validates, and caches project-local skill definitions.
+    class Catalog
+      def initialize(project_root:)
+        @project_root = project_root
+        @last_reload_report = nil
+      end
+
+      def all_skills
+        valid_skills.sort_by { |skill| [-skill.priority, skill.name.downcase] }
+      end
+
+      def skills_for_mode(mode)
+        all_skills.select { |skill| skill.applies_to_mode?(mode) }
+      end
+
+      def relevant_skills_for(mode:, input: nil)
+        mode_skills = skills_for_mode(mode)
+        return mode_skills if input.to_s.strip.empty?
+
+        matched = mode_skills.select { |skill| matches_input?(skill, input) }
+        matched.empty? ? mode_skills : matched.sort_by { |skill| [-skill.priority, skill.name.downcase] }
+      end
+
+      def reload!
+        previous_names = cached_skill_names
+        clear_cached_reports!
+        current_names = valid_skills.map { |skill| skill.name.downcase }
+        @last_reload_report = build_reload_report(previous_names, current_names)
+      end
+
+      def last_reload_report
+        @last_reload_report || default_reload_report
+      end
+
+      private
+
+      def cached_skill_names
+        return [] unless @valid_skills
+
+        @valid_skills.map { |skill| skill.name.downcase }
+      end
+
+      def clear_cached_reports!
+        @load_report = nil
+        @valid_skills = nil
+      end
+
+      def default_reload_report
+        build_reload_report([], valid_skills.map { |skill| skill.name.downcase }).merge(added: 0)
+      end
+
+      def build_reload_report(previous_names, current_names)
+        {
+          total: current_names.size,
+          added: (current_names - previous_names).size,
+          removed: (previous_names - current_names).size,
+          invalid: load_report[:invalid_count],
+          invalid_files: load_report[:invalid_files],
+          duplicates: duplicate_names.size,
+          duplicate_skills: duplicate_names
+        }
+      end
+
+      def valid_skills
+        @valid_skills ||= load_report[:entries]
+                          .uniq { |entry| entry[:name].downcase }
+                          .map { |entry| build_definition(entry) }
+      end
+
+      def duplicate_names
+        counts = Hash.new(0)
+        load_report[:entries].each { |entry| counts[entry[:name].downcase] += 1 }
+        counts.select { |_name, count| count > 1 }.keys.sort
+      end
+
+      def build_definition(entry)
+        SkillDefinition.new(**entry)
+      end
+
+      def matches_input?(skill, input)
+        haystack = input.to_s.downcase
+        trigger_match = !skill.trigger.to_s.empty? && haystack.include?(skill.trigger.downcase)
+        tag_match = skill.tags.any? { |tag| haystack.include?(tag.downcase) }
+        trigger_match || tag_match
+      end
+
+      def loader
+        @loader ||= MarkdownLoader.new(project_root: @project_root)
+      end
+
+      def load_report
+        @load_report ||= loader.load_report
+      end
+    end
+  end
+end

data/lib/ruby_coded/skills/markdown_loader.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module RubyCoded
+  module Skills
+    # Loads project-local markdown skill files.
+    class MarkdownLoader
+      SUPPORTED_MODES = %w[chat plan agent].freeze
+
+      def initialize(project_root:)
+        @project_root = project_root
+      end
+
+      def load_files
+        load_report[:entries]
+      end
+
+      def load_report
+        return empty_report unless Dir.exist?(skills_dir)
+
+        build_report(skill_paths)
+      end
+
+      private
+
+      def empty_report
+        { entries: [], invalid_count: 0, invalid_files: [] }
+      end
+
+      def build_report(paths)
+        entries, invalid_files = paths.each_with_object([[], []]) do |path, memo|
+          collect_report_entry(path, *memo)
+        end
+
+        {
+          entries: entries,
+          invalid_count: invalid_files.size,
+          invalid_files: invalid_files
+        }
+      end
+
+      def collect_report_entry(path, entries, invalid_files)
+        parsed = parse_file(path)
+        parsed ? entries << parsed : invalid_files << File.basename(path)
+      end
+
+      def skill_paths
+        Dir.glob(File.join(skills_dir, "*.md"))
+      end
+
+      def skills_dir
+        File.join(@project_root, ".rubycoded", "skills")
+      end
+
+      def parse_file(path)
+        frontmatter, body = extract_frontmatter(File.read(path))
+        return nil unless frontmatter
+
+        build_entry(path, extract_attributes(frontmatter, body))
+      rescue StandardError
+        nil
+      end
+
+      def extract_attributes(frontmatter, body)
+        data = YAML.safe_load(frontmatter) || {}
+        {
+          name: data["name"]&.strip,
+          description: data["description"]&.strip,
+          modes: normalize_modes(data["modes"]),
+          trigger: data["trigger"]&.strip,
+          priority: data["priority"],
+          tags: normalize_tags(data["tags"]),
+          content: body.to_s.strip
+        }
+      end
+
+      def normalize_modes(value)
+        Array(value).map { |mode| mode.to_s.strip.downcase }.reject(&:empty?)
+      end
+
+      def normalize_tags(value)
+        Array(value).map { |tag| tag.to_s.strip }.reject(&:empty?)
+      end
+
+      def build_entry(path, attrs)
+        return nil unless valid_entry?(attrs)
+
+        attrs.merge(path: path)
+      end
+
+      def valid_entry?(attrs)
+        required_fields_present?(attrs) && valid_modes?(attrs[:modes])
+      end
+
+      def required_fields_present?(attrs)
+        %i[name description content].all? { |field| !attrs[field].to_s.empty? }
+      end
+
+      def valid_modes?(modes)
+        modes.any? && modes.all? { |mode| SUPPORTED_MODES.include?(mode) }
+      end
+
+      def extract_frontmatter(raw)
+        match = raw.match(/\A---\s*\n(.*?)\n---\s*\n?(.*)\z/m)
+        return [nil, nil] unless match
+
+        [match[1], match[2]]
+      end
+    end
+  end
+end