yorishiro 0.1.0 → 0.2.0

data/lib/yorishiro/compactor.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Yorishiro
+  # Summarizes older conversation history into a compact summary so long
+  # sessions stay within the model's context window (similar to Claude Code's
+  # auto-compaction). Uses the active provider to generate the summary.
+  class Compactor
+    KEEP_RECENT_ROUNDS = 2
+
+    SUMMARY_SYSTEM_PROMPT = <<~PROMPT
+      You compress conversation history for an AI coding assistant. Produce a
+      concise but complete summary that preserves everything needed to continue
+      the work: the user's goals and requests, key decisions made, files and
+      code examined or changed, tool results that still matter, and any
+      unresolved questions or next steps. Prefer terse bullet points. Do not add
+      commentary or ask questions — output only the summary.
+    PROMPT
+
+    SUMMARY_INSTRUCTION = "Summarize the following conversation transcript so the assistant can continue seamlessly:"
+
+    def initialize(provider)
+      @provider = provider
+    end
+
+    # Compact the given conversation in place. Returns the number of messages
+    # that were summarized away (0 if nothing was compacted).
+    def compact(conversation, keep_recent_rounds: KEEP_RECENT_ROUNDS)
+      conversation.compact!(keep_recent_rounds: keep_recent_rounds) do |old_messages|
+        summarize(old_messages)
+      end
+    end
+
+    private
+
+    def summarize(old_messages)
+      transcript = old_messages.map { |msg| format_message(msg) }.join("\n\n")
+
+      request = Conversation.new(system_prompt: SUMMARY_SYSTEM_PROMPT)
+      request.add_message(:user, "#{SUMMARY_INSTRUCTION}\n\n#{transcript}")
+
+      @provider.chat(request)[:content]
+    end
+
+    def format_message(msg)
+      lines = ["#{msg[:role]}: #{msg[:content]}"]
+      if msg[:tool_calls]
+        calls = msg[:tool_calls].map { |tc| "#{tc[:name]}(#{tc[:arguments]})" }.join(", ")
+        lines << "  [tool_calls: #{calls}]"
+      end
+      lines.join("\n")
+    end
+  end
+end

data/lib/yorishiro/configuration.rb

@@ -3,7 +3,8 @@
 module Yorishiro
   class Configuration
     attr_reader :provider_name, :api_key, :model, :allowed_tools, :skills,
-                :mcp_servers, :system_prompt_text, :plan_mode_enabled
+                :mcp_servers, :system_prompt_text, :plan_mode_enabled, :ollama_num_ctx_value,
+                :auto_compact_enabled, :hooks
 
     def initialize
       @provider_name = nil
@@ -14,6 +15,9 @@ module Yorishiro
       @mcp_servers = {}
       @system_prompt_text = nil
       @plan_mode_enabled = false
+      @ollama_num_ctx_value = nil
+      @auto_compact_enabled = true
+      @hooks = Hooks.new
     end
 
     def use(provider:, api_key: nil, model: nil)
@@ -22,6 +26,20 @@ module Yorishiro
       @model = model
     end
 
+    # Switch provider/model at runtime (e.g. the /model command). Re-validates
+    # and rolls back to the previous settings if the new combination is
+    # invalid, so a rejected switch never leaves the config half-changed.
+    def switch!(provider:, model:, api_key:)
+      previous = [@provider_name, @api_key, @model]
+      @provider_name = provider
+      @api_key = api_key
+      @model = model
+      validate!
+    rescue ConfigurationError
+      @provider_name, @api_key, @model = previous
+      raise
+    end
+
     def allow_tool(tool, **options)
       tool.configure(options) if tool.respond_to?(:configure)
       @allowed_tools << tool
@@ -34,6 +52,15 @@ module Yorishiro
       @skills << skill_instance
     end
 
+    # Register a skill, replacing any same-name skill registered earlier
+    # (so ./.yorishiro/skills overrides ~/.yorishiro/skills).
+    def replace_skill(skill_instance)
+      raise SkillNotImplementedError, "Skill must implement #name" unless skill_instance.respond_to?(:name)
+
+      @skills.reject! { |s| s.name == skill_instance.name }
+      skill(skill_instance)
+    end
+
     def mcp_server(name, command:, args: [], env: {})
       @mcp_servers[name] = { command: command, args: args, env: env }
     end
@@ -46,9 +73,38 @@ module Yorishiro
       @plan_mode_enabled = enabled
     end
 
+    # Override the Ollama context window (num_ctx). Set from .yorishirorc, e.g.
+    # `ollama_num_ctx 16384`. Also settable via the OLLAMA_NUM_CTX env var.
+    def ollama_num_ctx(value)
+      @ollama_num_ctx_value = value
+    end
+
+    # Toggle automatic context compaction (LLM summarization of old history
+    # when the conversation nears the context window). Enabled by default;
+    # disable from .yorishirorc with `auto_compact false`.
+    def auto_compact(enabled)
+      @auto_compact_enabled = enabled
+    end
+
+    # Register a lifecycle hook from .yorishirorc, e.g.
+    #   on :before_tool_use do |tool_name, args|
+    #     deny("rm is not allowed") if args["command"].to_s.start_with?("rm")
+    #   end
+    def on(event, &)
+      @hooks.on(event, &)
+    end
+
+    # Hook helper: return deny("reason") from a before_tool_use or
+    # user_prompt_submit block to veto the action.
+    def deny(reason = "denied by hook")
+      Hooks::Denial.new(reason)
+    end
+
     def load!
       load_rc_file(global_rc_path)
       load_rc_file(local_rc_path)
+      load_skill_files(global_skills_dir)
+      load_skill_files(local_skills_dir)
       validate!
     end
 
@@ -86,6 +142,18 @@ module Yorishiro
       File.join(Dir.pwd, ".lyorishirorc")
     end
 
+    def global_skills_dir
+      File.join(Dir.home, ".yorishiro", "skills")
+    end
+
+    def local_skills_dir
+      File.join(Dir.pwd, ".yorishiro", "skills")
+    end
+
+    def load_skill_files(dir)
+      SkillLoader.new(self).load_dir(dir)
+    end
+
     def load_rc_file(path)
       return unless File.exist?(path)
 

data/lib/yorishiro/conversation.rb

@@ -2,6 +2,10 @@
 
 module Yorishiro
   class Conversation
+    # Rough heuristic used to estimate token counts without a real tokenizer.
+    # English/code averages ~4 characters per token.
+    CHARS_PER_TOKEN = 4
+
     attr_reader :messages
 
     def initialize(system_prompt: nil)
@@ -44,6 +48,31 @@ module Yorishiro
       @messages.clear
     end
 
+    # JSON-safe deep copy of the messages (string keys) for session
+    # persistence. The system prompt is intentionally excluded — a resumed
+    # session uses whatever the current configuration provides.
+    def serializable_messages
+      JSON.parse(JSON.generate(@messages))
+    end
+
+    # Replace the messages with ones loaded from a saved session
+    # (string-keyed hashes as produced by #serializable_messages).
+    # Tool-call arguments keep their string keys: providers pass them
+    # through as-is and the CLI symbolizes at execution time, matching the
+    # live message flow.
+    def restore_messages!(raw_messages)
+      @messages = raw_messages.map do |msg|
+        role = msg["role"].to_sym
+        validate_role!(role)
+        {
+          role: role,
+          content: msg["content"],
+          tool_calls: msg["tool_calls"]&.map { |tc| { id: tc["id"], name: tc["name"], arguments: tc["arguments"] } },
+          tool_call_id: msg["tool_call_id"]
+        }.compact
+      end
+    end
+
     def last_role
       @messages.last&.fetch(:role, nil)
     end
@@ -52,8 +81,96 @@ module Yorishiro
       @messages.length
     end
 
+    # Rough estimate of the prompt size in tokens (system prompt + all messages).
+    def estimated_tokens
+      total = @system_prompt.to_s.length
+      total += @messages.sum { |msg| message_char_size(msg) }
+      (total.to_f / CHARS_PER_TOKEN).ceil
+    end
+
+    # Replace the oldest rounds with a single summary while keeping the most
+    # recent +keep_recent_rounds+ rounds verbatim. The block receives the old
+    # messages and must return the summary text; rounds are handled whole so a
+    # tool call is never split from its result, and the summary is inserted as a
+    # leading :user message (keeping the user-first ordering providers expect).
+    # Returns the number of messages that were compacted away (0 if there was
+    # nothing old enough to compact or the summary came back empty).
+    def compact!(keep_recent_rounds: 2)
+      starts = user_message_indices
+      return 0 if starts.length <= keep_recent_rounds
+
+      cut = starts[starts.length - keep_recent_rounds]
+      old = @messages[0...cut]
+      return 0 if old.empty?
+
+      summary = yield(old)
+      return 0 if summary.nil? || summary.strip.empty?
+
+      @messages = [summary_message(summary)] + (@messages[cut..] || [])
+      old.length
+    end
+
+    ELIDED_TOOL_RESULT = "[Old tool result removed to free context. Re-run the tool if the output is needed again.]"
+
+    # Replace the contents of the oldest tool results with a short
+    # placeholder until the conversation fits within +max_tokens+, keeping
+    # the most recent +keep_recent+ tool results verbatim. Unlike
+    # trim_to_budget!, this frees space inside a single round — a long tool
+    # loop after one user message — where whole-round trimming cannot drop
+    # anything. Message structure is preserved, so an assistant tool_call is
+    # never left without its result. Returns the number of results elided.
+    def elide_old_tool_results!(max_tokens:, keep_recent: 2)
+      tool_indices = @messages.each_index.select { |i| @messages[i][:role] == :tool }
+      candidates = keep_recent.positive? ? tool_indices[0...-keep_recent] : tool_indices
+      elided = 0
+
+      (candidates || []).each do |index|
+        break if estimated_tokens <= max_tokens
+        next if @messages[index][:content] == ELIDED_TOOL_RESULT
+
+        @messages[index][:content] = ELIDED_TOOL_RESULT
+        elided += 1
+      end
+
+      elided
+    end
+
+    # Drop the oldest conversation rounds until the estimated size fits within
+    # +max_tokens+. A "round" starts at a :user message and includes the
+    # assistant reply and any tool results that follow, so whole rounds are
+    # removed together — never splitting an assistant tool_call from its tool
+    # result. The system prompt and the most recent round are always kept.
+    # Returns the number of messages removed.
+    def trim_to_budget!(max_tokens:)
+      removed_count = 0
+
+      while estimated_tokens > max_tokens
+        round_starts = user_message_indices
+        break if round_starts.length <= 1 # keep at least the latest round
+
+        removed = @messages.slice!(0, round_starts[1])
+        removed_count += removed.length
+      end
+
+      removed_count
+    end
+
     private
 
+    def user_message_indices
+      @messages.each_index.select { |i| @messages[i][:role] == :user }
+    end
+
+    def summary_message(summary)
+      { role: :user, content: "[Summary of earlier conversation]\n#{summary}" }
+    end
+
+    def message_char_size(msg)
+      size = msg[:content].to_s.length
+      size += msg[:tool_calls].to_s.length if msg[:tool_calls]
+      size
+    end
+
     def validate_role!(role)
       return if %i[user assistant tool].include?(role)
 

data/lib/yorishiro/diff.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Yorishiro
+  # Minimal unified-diff generator used to preview file changes in the
+  # permission prompt. A single hunk is built by stripping the common
+  # prefix/suffix lines — accurate for the local edits tools make, and
+  # O(n) without an external diff gem.
+  module Diff
+    CONTEXT_LINES = 3
+    MAX_DIFF_LINES = 200
+
+    module_function
+
+    # Returns a unified diff between the two texts, or nil when they are
+    # identical. When old_text is empty the file is treated as new
+    # (--- /dev/null, every line added).
+    def unified(old_text, new_text, path:)
+      return nil if old_text == new_text
+
+      old_lines = old_text.lines(chomp: true)
+      new_lines = new_text.lines(chomp: true)
+
+      prefix = common_prefix_length(old_lines, new_lines)
+      suffix = common_suffix_length(old_lines, new_lines, prefix)
+
+      removed = old_lines[prefix...(old_lines.length - suffix)] || []
+      added = new_lines[prefix...(new_lines.length - suffix)] || []
+
+      header(old_text, path) + hunk(old_lines, prefix, suffix, removed, added)
+    end
+
+    # Adds ANSI colors to a diff produced by .unified. Kept separate so
+    # callers can decide whether the output supports color.
+    def colorize(diff_text)
+      diff_text.lines(chomp: true).map { |line| colorize_line(line) }.join("\n")
+    end
+
+    def common_prefix_length(old_lines, new_lines)
+      max = [old_lines.length, new_lines.length].min
+      (0...max).each { |i| return i if old_lines[i] != new_lines[i] }
+      max
+    end
+
+    def common_suffix_length(old_lines, new_lines, prefix)
+      max = [old_lines.length, new_lines.length].min - prefix
+      (0...max).each { |i| return i if old_lines[-1 - i] != new_lines[-1 - i] }
+      max
+    end
+
+    def header(old_text, path)
+      # "/dev/null" is the unified-diff convention for a new file, not a
+      # filesystem path, so File::NULL would be wrong on Windows.
+      original = old_text.empty? ? "/dev/null" : path # rubocop:disable Style/FileNull
+      "--- #{original}\n+++ #{path}\n"
+    end
+
+    def hunk(old_lines, prefix, suffix, removed, added)
+      context_start = [prefix - CONTEXT_LINES, 0].max
+      before = old_lines[context_start...prefix] || []
+      after = old_lines[old_lines.length - suffix, CONTEXT_LINES] || []
+
+      old_count = before.length + removed.length + after.length
+      new_count = before.length + added.length + after.length
+      old_start = old_count.zero? ? 0 : context_start + 1
+      new_start = new_count.zero? ? 0 : context_start + 1
+
+      lines = ["@@ -#{old_start},#{old_count} +#{new_start},#{new_count} @@"]
+      lines += before.map { |l| " #{l}" }
+      lines += removed.map { |l| "-#{l}" }
+      lines += added.map { |l| "+#{l}" }
+      lines += after.map { |l| " #{l}" }
+      truncate(lines).join("\n")
+    end
+
+    def truncate(lines)
+      return lines if lines.length <= MAX_DIFF_LINES
+
+      lines.first(MAX_DIFF_LINES) + ["... (diff truncated, #{lines.length - MAX_DIFF_LINES} more lines)"]
+    end
+
+    def colorize_line(line)
+      return line if line.start_with?("--- ", "+++ ")
+
+      case line
+      when /\A@@/ then "\e[36m#{line}\e[0m"
+      when /\A\+/ then "\e[32m#{line}\e[0m"
+      when /\A-/ then "\e[31m#{line}\e[0m"
+      else line
+      end
+    end
+  end
+end

data/lib/yorishiro/hooks.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Yorishiro
+  # Registry for lifecycle hooks declared in .yorishirorc via the `on` DSL.
+  # before_tool_use / user_prompt_submit blocks can veto the action by
+  # returning :deny or a Denial (built with the `deny("reason")` helper).
+  # Any other return value (including nil) lets the action proceed, so
+  # logging-only hooks are safe by default.
+  class Hooks
+    EVENTS = %i[before_tool_use after_tool_use user_prompt_submit].freeze
+
+    Denial = Struct.new(:reason)
+
+    def initialize
+      @blocks = Hash.new { |hash, key| hash[key] = [] }
+    end
+
+    def on(event, &block)
+      raise ConfigurationError, "Unknown hook event: #{event}. Available events: #{EVENTS.join(", ")}" unless EVENTS.include?(event)
+
+      @blocks[event] << block
+    end
+
+    def any?(event)
+      @blocks[event].any?
+    end
+
+    # Returns nil to proceed, or a Denial. A hook that raises denies the
+    # call (fail closed) so a broken guard cannot silently let tools run.
+    def run_before_tool_use(tool_name, arguments)
+      first_denial(:before_tool_use, tool_name, arguments)
+    end
+
+    def run_user_prompt_submit(input)
+      first_denial(:user_prompt_submit, input)
+    end
+
+    # Exceptions propagate to the caller: after hooks are observational,
+    # so the CLI just warns and keeps the tool result.
+    def run_after_tool_use(tool_name, arguments, result)
+      @blocks[:after_tool_use].each { |block| block.call(tool_name, arguments, result) }
+      nil
+    end
+
+    private
+
+    def first_denial(event, *args)
+      @blocks[event].each do |block|
+        denial = to_denial(block.call(*args))
+        return denial if denial
+      rescue StandardError => e
+        return Denial.new("hook raised #{e.class}: #{e.message}")
+      end
+      nil
+    end
+
+    def to_denial(value)
+      case value
+      when Denial then value
+      when :deny then Denial.new("denied by hook")
+      end
+    end
+  end
+end

data/lib/yorishiro/input_history.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "reline"
+
+module Yorishiro
+  # Persists the Reline input-line history to disk so that past prompts can be
+  # recalled with the up arrow across sessions. The history file lives under the
+  # launch directory (cwd), so each project keeps its own history. Entries are
+  # stored as a JSON array of strings; JSON is used (rather than newline-
+  # separated text) because a single multi-line input is one entry containing
+  # embedded newlines.
+  class InputHistory
+    DIR_NAME = ".yorishiro"
+    FILE_NAME = "history.json"
+
+    # Cap the on-disk history so it does not grow without bound.
+    MAX_ENTRIES = 1000
+
+    def initialize(dir: Dir.pwd, max_entries: MAX_ENTRIES)
+      @path = File.join(dir, DIR_NAME, FILE_NAME)
+      @max_entries = max_entries
+    end
+
+    attr_reader :path
+
+    # Populate Reline::HISTORY from the saved file. No-op if the file is absent
+    # or unreadable/corrupt (a broken history file should never block startup).
+    def load
+      return unless File.exist?(@path)
+
+      entries = JSON.parse(File.read(@path))
+      return unless entries.is_a?(Array)
+
+      entries.each { |entry| Reline::HISTORY << entry.to_s }
+    rescue JSON::ParserError, SystemCallError
+      nil
+    end
+
+    # Write the current Reline::HISTORY (trimmed to the most recent
+    # +max_entries+) to disk as a JSON array.
+    def save
+      FileUtils.mkdir_p(File.dirname(@path))
+      entries = Reline::HISTORY.to_a.last(@max_entries)
+      File.write(@path, JSON.generate(entries))
+    rescue SystemCallError
+      nil
+    end
+  end
+end

data/lib/yorishiro/mcp/server_manager.rb

@@ -23,7 +23,7 @@ module Yorishiro
 
       def stop_all
         @servers.each_value do |server|
-          server[:transport].stop
+          server[:transport].close
         rescue StandardError => e
           warn "[MCP] Error stopping server: #{e.message}"
         end
@@ -33,14 +33,14 @@ module Yorishiro
       private
 
       def start_server(name, config)
-        transport = StdioTransport.new(
+        transport = ::MCP::Client::Stdio.new(
           command: config[:command],
           args: config.fetch(:args, []),
-          env: config.fetch(:env, {})
+          env: config.fetch(:env, {}).compact
         )
-        transport.start
 
         client = ::MCP::Client.new(transport: transport)
+        client.connect
 
         mcp_tools = client.tools
         mcp_tools.each do |mcp_tool|

data/lib/yorishiro/provider/anthropic.rb

@@ -6,12 +6,20 @@ module Yorishiro
       API_URL = "https://api.anthropic.com/v1/messages"
       API_VERSION = "2023-06-01"
 
+      # Alias IDs (no date suffix) from Anthropic's model catalog. Aliases
+      # track the latest snapshot of each model, so this list goes stale far
+      # more slowly than the dated IDs it used to hold — but it is still a
+      # snapshot: add new entries here as models are released.
       SUPPORTED_MODELS = %w[
-        claude-opus-4-20250514
-        claude-sonnet-4-20250514
-        claude-haiku-4-20250414
-        claude-3-5-sonnet-20241022
-        claude-3-5-haiku-20241022
+        claude-fable-5
+        claude-opus-4-8
+        claude-opus-4-7
+        claude-opus-4-6
+        claude-opus-4-5
+        claude-sonnet-5
+        claude-sonnet-4-6
+        claude-sonnet-4-5
+        claude-haiku-4-5
       ].freeze
 
       def self.supported_models
@@ -38,17 +46,20 @@ module Yorishiro
           "anthropic-version" => API_VERSION
         }
 
-        post_stream(uri, headers: headers, body: body, &)
+        @last_usage = {}
+        result = post_stream(uri, headers: headers, body: body, &)
+        result[:usage] = @last_usage
+        result
       end
 
       private
 
       def default_model
-        "claude-sonnet-4-20250514"
+        "claude-opus-4-8"
       end
 
       def format_messages(api_messages)
-        messages = api_messages.reject { |m| m[:role] == "system" }
+        messages = api_messages.reject { |m| m[:role] == "system" || empty_assistant?(m) }
 
         messages.map do |msg|
           if msg[:role] == "tool"
@@ -78,6 +89,14 @@ module Yorishiro
         end
       end
 
+      # The API rejects assistant messages whose content is empty, and the
+      # error repeats on every request — so an empty completion recorded in
+      # the history (e.g. by a session saved before the CLI filtered them
+      # out) is dropped rather than poisoning the whole session.
+      def empty_assistant?(msg)
+        msg[:role] == "assistant" && msg[:tool_calls].to_a.empty? && msg[:content].to_s.strip.empty?
+      end
+
       def extract_system_prompt(api_messages)
         system_msg = api_messages.find { |m| m[:role] == "system" }
         system_msg&.fetch(:content, nil)
@@ -93,6 +112,14 @@ module Yorishiro
         end
       end
 
+      # input_tokens arrives on message_start, output_tokens on message_delta.
+      def capture_usage(data)
+        input = data.dig("message", "usage", "input_tokens")
+        output = data.dig("usage", "output_tokens")
+        @last_usage[:input] = input if input
+        @last_usage[:output] = output if output
+      end
+
       def parse_stream(response, tool_calls:, &block)
         buffer = +""
         current_tool_call = nil
@@ -105,6 +132,8 @@ module Yorishiro
             next unless parsed[:data]
 
             case parsed[:event] || parsed[:data]["type"]
+            when "message_start", "message_delta"
+              capture_usage(parsed[:data])
             when "content_block_start"
               content_block = parsed[:data]["content_block"]
               if content_block && content_block["type"] == "tool_use"

data/lib/yorishiro/provider/base.rb

@@ -29,22 +29,33 @@ module Yorishiro
       def debug_log(label, data = nil)
         return unless debug?
 
-        $stderr.puts "[DEBUG] #{label}"
-        $stderr.puts(data.is_a?(String) ? data : JSON.pretty_generate(data)) if data
+        warn "[DEBUG] #{label}"
+        warn(data.is_a?(String) ? data : JSON.pretty_generate(data)) if data
       rescue StandardError
         nil
       end
 
+      # Token budget the conversation should be trimmed to before each request.
+      # nil means "no known context window" — the conversation is not trimmed.
+      # Providers with a fixed local context window (Ollama) override this.
+      def context_budget_tokens
+        nil
+      end
+
       private
 
       def default_model
         raise ProviderNotImplementedError, "#{self.class}#default_model is not implemented"
       end
 
+      def read_timeout
+        120
+      end
+
       def post_stream(uri, headers:, body:, &block)
         http = Net::HTTP.new(uri.host, uri.port)
         http.use_ssl = (uri.scheme == "https")
-        http.read_timeout = 120
+        http.read_timeout = read_timeout
 
         request = Net::HTTP::Post.new(uri)
         headers.each { |k, v| request[k] = v }
@@ -115,7 +126,12 @@ module Yorishiro
 
     def self.build(config)
       provider_class = self.for(config.provider_name)
-      provider_class.new(api_key: config.api_key, model: config.model)
+
+      if config.provider_name == :ollama
+        provider_class.new(api_key: config.api_key, model: config.model, num_ctx: config.ollama_num_ctx_value)
+      else
+        provider_class.new(api_key: config.api_key, model: config.model)
+      end
     end
   end
 end