yorishiro 0.1.0 → 0.2.0

data/lib/yorishiro/provider/ollama.rb

@@ -4,9 +4,13 @@ module Yorishiro
   module Provider
     class Ollama < Base
       DEFAULT_BASE_URL = "http://localhost:11434"
+      DEFAULT_NUM_CTX = 8192
+      OUTPUT_TOKEN_RESERVE = 2048
+      MIN_CONTEXT_BUDGET = 1024
 
-      def initialize(api_key: nil, model: nil, base_url: nil)
+      def initialize(api_key: nil, model: nil, base_url: nil, num_ctx: nil)
         @base_url = base_url || ENV.fetch("OLLAMA_HOST", DEFAULT_BASE_URL)
+        @num_ctx = num_ctx
         super(api_key: api_key || "unused", model: model)
       end
 
@@ -22,32 +26,60 @@ module Yorishiro
         []
       end
 
-      def chat(conversation, tools: [], &block)
+      def chat(conversation, tools: [], &)
         uri = URI("#{@base_url}/api/chat")
 
         body = {
           model: @model_name,
-          messages: format_messages(conversation.to_api_messages)
+          messages: format_messages(conversation.to_api_messages),
+          keep_alive: ENV.fetch("OLLAMA_KEEP_ALIVE", "10m"),
+          options: { num_ctx: num_ctx },
+          stream: true
         }
 
         headers = { "Content-Type" => "application/json" }
 
-        if tools.empty?
-          body[:stream] = true
-          post_stream(uri, headers: headers, body: body, &block)
-        else
-          body[:stream] = false
-          body[:tools] = format_tools(tools)
-          post_no_stream(uri, headers: headers, body: body, &block)
-        end
+        body[:tools] = format_tools(tools) unless tools.empty?
+
+        debug_log("Ollama request", body)
+
+        @last_meta = {}
+        result = post_stream(uri, headers: headers, body: body, &)
+        result[:meta] = @last_meta
+        result[:usage] = { input: @last_meta[:prompt_eval_count], output: @last_meta[:eval_count] }
+        debug_log("Ollama response", result)
+        result
+      end
+
+      # Token budget the conversation should be trimmed to before each request.
+      # Reserves headroom for the model's output within the configured context window.
+      def context_budget_tokens
+        [num_ctx - OUTPUT_TOKEN_RESERVE, MIN_CONTEXT_BUDGET].max
       end
 
       private
 
+      # Resolve the Ollama context window (num_ctx). Priority:
+      #   1. explicit value from .yorishirorc (constructor argument)
+      #   2. OLLAMA_NUM_CTX environment variable
+      #   3. DEFAULT_NUM_CTX
+      def num_ctx
+        return @num_ctx.to_i if @num_ctx
+
+        env = ENV.fetch("OLLAMA_NUM_CTX", nil)
+        return env.to_i if env && !env.empty?
+
+        DEFAULT_NUM_CTX
+      end
+
       def default_model
         "llama3.1"
       end
 
+      def read_timeout
+        nil # local inference (prompt eval on large inputs) can take arbitrarily long
+      end
+
       def format_messages(api_messages)
         api_messages.map do |msg|
           if msg[:role] == "tool"
@@ -83,39 +115,6 @@ module Yorishiro
         end
       end
 
-      def post_no_stream(uri, headers:, body:, &block)
-        http = Net::HTTP.new(uri.host, uri.port)
-        http.use_ssl = (uri.scheme == "https")
-        http.read_timeout = 120
-
-        request = Net::HTTP::Post.new(uri)
-        headers.each { |k, v| request[k] = v }
-        request.body = JSON.generate(body)
-
-        debug_log("Ollama request", body)
-
-        response = http.request(request)
-        handle_error_response!(response) unless response.is_a?(Net::HTTPSuccess)
-
-        data = JSON.parse(response.body)
-        debug_log("Ollama response", data)
-        message = data["message"] || {}
-
-        content = message["content"] || ""
-        block&.call(content) unless content.empty?
-
-        tool_calls = (message["tool_calls"] || []).map do |tc|
-          func = tc["function"]
-          {
-            id: "ollama_#{SecureRandom.hex(8)}",
-            name: func["name"],
-            arguments: func["arguments"].is_a?(Hash) ? func["arguments"] : JSON.parse(func["arguments"].to_s)
-          }
-        end
-
-        { content: content, tool_calls: tool_calls }
-      end
-
       def parse_stream(response, tool_calls:, &block)
         buffer = +""
 
@@ -125,7 +124,13 @@ module Yorishiro
             line = buffer.slice!(0, idx + 1).strip
             next if line.empty?
 
-            data = JSON.parse(line)
+            data = parse_ndjson_line(line)
+            next unless data
+
+            raise ProviderError, "Ollama error: #{data["error"]}" if data["error"]
+
+            capture_meta(data)
+
             message = data["message"]
             next unless message
 
@@ -146,6 +151,26 @@ module Yorishiro
           end
         end
       end
+
+      # Parse a single NDJSON line, skipping (rather than crashing on) malformed
+      # or partial lines that Ollama can emit under load or on unexpected output.
+      def parse_ndjson_line(line)
+        JSON.parse(line)
+      rescue JSON::ParserError => e
+        debug_log("Ollama: skipping malformed NDJSON line", e.message)
+        nil
+      end
+
+      # Capture the final-chunk stats so the CLI can detect context truncation
+      # (prompt_eval_count approaching num_ctx) and empty responses.
+      def capture_meta(data)
+        return unless data["done"]
+
+        @last_meta ||= {}
+        %w[done_reason prompt_eval_count eval_count].each do |key|
+          @last_meta[key.to_sym] = data[key] if data.key?(key)
+        end
+      end
     end
   end
 end

data/lib/yorishiro/provider/open_ai.rb

@@ -5,15 +5,15 @@ module Yorishiro
     class OpenAI < Base
       API_URL = "https://api.openai.com/v1/chat/completions"
 
+      # Chat-completions models compatible with this client, which always
+      # streams and sends system messages and tools — the o1/o3 reasoning
+      # series rejects parts of that flow, so it is intentionally absent.
       SUPPORTED_MODELS = %w[
         gpt-4o
         gpt-4o-mini
         gpt-4-turbo
         gpt-4
         gpt-3.5-turbo
-        o1
-        o1-mini
-        o3-mini
       ].freeze
 
       def self.supported_models
@@ -26,7 +26,8 @@ module Yorishiro
         body = {
           model: @model_name,
           messages: format_messages(conversation.to_api_messages),
-          stream: true
+          stream: true,
+          stream_options: { include_usage: true }
         }
         body[:tools] = format_tools(tools) unless tools.empty?
 
@@ -35,7 +36,10 @@ module Yorishiro
           "Authorization" => "Bearer #{@api_key}"
         }
 
-        post_stream(uri, headers: headers, body: body, &)
+        @last_usage = {}
+        result = post_stream(uri, headers: headers, body: body, &)
+        result[:usage] = @last_usage
+        result
       end
 
       private
@@ -85,6 +89,16 @@ module Yorishiro
         end
       end
 
+      # A trailing usage-only chunk (with an empty choices array) carries the
+      # token counts when stream_options.include_usage is set.
+      def capture_usage(data)
+        usage = data["usage"]
+        return unless usage
+
+        @last_usage[:input] = usage["prompt_tokens"]
+        @last_usage[:output] = usage["completion_tokens"]
+      end
+
       def parse_stream(response, tool_calls:, &block)
         buffer = +""
         tool_call_buffers = {}
@@ -96,6 +110,8 @@ module Yorishiro
             parsed = parse_sse_event(event_str)
             next unless parsed[:data]
 
+            capture_usage(parsed[:data])
+
             choice = parsed[:data].dig("choices", 0)
             next unless choice
 

data/lib/yorishiro/session_resume.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "reline"
+
+module Yorishiro
+  # Interactive session-resume flows shared by the --continue/--resume CLI
+  # flags and the /resume command. Applies the chosen session to the
+  # conversation and returns its id, or nil when nothing was resumed (the
+  # caller keeps its current session in that case).
+  class SessionResume
+    def initialize(store:, conversation:, output:, current_target:)
+      @store = store
+      @conversation = conversation
+      @output = output
+      @current_target = current_target # "provider:model" of the running CLI
+    end
+
+    def continue_latest
+      apply(@store.latest, missing: "No previous session found. Starting a new one.")
+    end
+
+    def resume_by_id(id)
+      apply(@store.load(id), missing: "Session not found: #{id}")
+    end
+
+    def pick
+      sessions = @store.list
+      if sessions.empty?
+        @output.puts "[i] No saved sessions."
+        return nil
+      end
+
+      print_list(sessions)
+      answer = Reline.readline("Select session [1-#{sessions.length}]: ", false)&.strip
+      index = answer.to_i
+      unless index.between?(1, sessions.length)
+        @output.puts "Cancelled."
+        return nil
+      end
+
+      apply(sessions[index - 1])
+    end
+
+    private
+
+    def apply(session, missing: "Session not found.")
+      unless session
+        @output.puts "[i] #{missing}"
+        return nil
+      end
+
+      unless @store.claim(session[:id])
+        @output.puts "[i] Session #{session[:id]} is in use by another process. Starting a new session."
+        return nil
+      end
+
+      @conversation.restore_messages!(session[:messages])
+
+      recorded = "#{session[:provider]}:#{session[:model]}"
+      @output.puts "[i] This session was recorded with #{recorded}. Continuing with #{@current_target}." if recorded != @current_target
+      @output.puts "[i] Resumed session #{session[:id]} (#{session[:title]}, #{session[:messages].length} messages)"
+      session[:id]
+    end
+
+    def print_list(sessions)
+      sessions.each_with_index do |session, index|
+        stamp = session[:updated_at].to_s[0, 16].tr("T", " ")
+        @output.puts "#{(index + 1).to_s.rjust(3)}. [#{stamp}] #{session[:provider]}:#{session[:model]} " \
+                     "(#{session[:messages].length} msgs) #{session[:title]}"
+      end
+    end
+  end
+end

data/lib/yorishiro/session_store.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Yorishiro
+  # Persists conversations to .yorishiro/sessions/<id>.json under the
+  # launch directory so they can be resumed later (--continue / --resume /
+  # /resume). Each session is one JSON file rewritten wholesale through an
+  # atomic tmp-file rename: compaction rewrites history destructively (an
+  # append-only log would need replaying), and the atomic swap means a
+  # crash mid-write never corrupts the previously saved state.
+  class SessionStore
+    DIR_NAME = File.join(".yorishiro", "sessions")
+    MAX_SESSIONS = 50
+    SCHEMA_VERSION = 1
+    TITLE_MAX_LENGTH = 60
+
+    def initialize(dir: Dir.pwd, max_sessions: MAX_SESSIONS)
+      @sessions_dir = File.join(dir, DIR_NAME)
+      @max_sessions = max_sessions
+      @locks = {}
+    end
+
+    attr_reader :sessions_dir
+
+    # Take exclusive ownership of a session id for this process, so a second
+    # `yorishiro` resuming the same session in the same directory doesn't
+    # write over this one's history (last-writer-wins data loss). Returns
+    # true when acquired (or already held by us), false when another live
+    # process owns it. The advisory lock is released automatically on
+    # process exit. Filesystems without flock fail open to preserve the
+    # single-user behaviour.
+    def claim(id)
+      return true if @locks.key?(id)
+
+      FileUtils.mkdir_p(@sessions_dir)
+      # Held open for the process lifetime so the advisory lock persists;
+      # the block form would close it and release the lock immediately.
+      lock = File.open(lock_path_for(id), File::CREAT | File::RDWR, 0o644) # rubocop:disable Style/FileOpen
+      if lock.flock(File::LOCK_EX | File::LOCK_NB)
+        @locks[id] = lock
+        true
+      else
+        lock.close
+        false
+      end
+    rescue SystemCallError
+      true
+    end
+
+    # Release every lock held by this store. The OS also releases them on
+    # process exit; this exists for tests and explicit teardown.
+    def release_locks
+      @locks.each_value { |lock| lock.close unless lock.closed? }
+      @locks.clear
+    end
+
+    # Write the session and return its id (generating one when nil). The
+    # original created_at is preserved across saves. Returns nil when the
+    # write fails — persistence must never break a REPL turn.
+    def save(id:, messages:, provider:, model:)
+      id ||= generate_id
+      claim(id)
+      existing = parse_session(path_for(id))
+      now = Time.now.utc.iso8601
+
+      session = {
+        version: SCHEMA_VERSION,
+        id: id,
+        provider: provider,
+        model: model,
+        created_at: existing&.dig(:created_at) || now,
+        updated_at: now,
+        title: title_from(messages),
+        messages: messages
+      }
+
+      write_atomically(path_for(id), JSON.generate(session))
+      prune!
+      id
+    rescue SystemCallError
+      nil
+    end
+
+    # Load a session by exact id or id prefix (most recent match wins).
+    # Returns nil when missing or corrupt.
+    def load(id)
+      path = path_for(id)
+      path = Dir.glob(File.join(@sessions_dir, "#{id}*.json")).max unless File.exist?(path)
+      return nil unless path
+
+      parse_session(path)
+    end
+
+    def latest
+      list.first
+    end
+
+    # All sessions, most recently updated first. Corrupt files are skipped.
+    def list
+      Dir.glob(File.join(@sessions_dir, "*.json"))
+         .filter_map { |path| parse_session(path) }
+         .sort_by { |session| session[:updated_at].to_s }
+         .reverse
+    end
+
+    private
+
+    def parse_session(path)
+      return nil unless File.exist?(path)
+
+      data = JSON.parse(File.read(path))
+      return nil unless data.is_a?(Hash) && data["messages"].is_a?(Array)
+
+      {
+        id: data["id"],
+        provider: data["provider"],
+        model: data["model"],
+        created_at: data["created_at"],
+        updated_at: data["updated_at"],
+        title: data["title"],
+        messages: data["messages"]
+      }
+    rescue JSON::ParserError, SystemCallError
+      nil
+    end
+
+    def write_atomically(path, content)
+      FileUtils.mkdir_p(@sessions_dir)
+      tmp_path = "#{path}.#{Process.pid}.tmp"
+      File.write(tmp_path, content)
+      File.rename(tmp_path, path)
+    end
+
+    def prune!
+      paths = Dir.glob(File.join(@sessions_dir, "*.json")).sort_by { |path| File.mtime(path) }
+      excess = paths.length - @max_sessions
+      return unless excess.positive?
+
+      paths.first(excess).each do |path|
+        File.delete(path)
+        FileUtils.rm_f("#{path}.lock")
+      end
+    rescue SystemCallError
+      nil
+    end
+
+    def path_for(id)
+      File.join(@sessions_dir, "#{id}.json")
+    end
+
+    def lock_path_for(id)
+      "#{path_for(id)}.lock"
+    end
+
+    # Timestamp prefix keeps ids readable and roughly sortable; the random
+    # suffix avoids collisions between sessions started in the same second.
+    def generate_id
+      "#{Time.now.strftime("%Y%m%dT%H%M%S")}-#{SecureRandom.hex(3)}"
+    end
+
+    def title_from(messages)
+      first_user = messages.find { |msg| msg["role"].to_s == "user" }
+      first_line = first_user&.fetch("content", nil).to_s.lines.first.to_s.strip
+      first_line.length > TITLE_MAX_LENGTH ? "#{first_line[0...TITLE_MAX_LENGTH]}..." : first_line
+    end
+  end
+end

data/lib/yorishiro/skill.rb

@@ -2,6 +2,17 @@
 
 module Yorishiro
   class Skill
+    # Returned from #execute to inject a prompt into the LLM instead of just
+    # printing output. The CLI feeds +text+ to the model as a user message and
+    # runs the agent/plan loop. Build one with the #prompt helper.
+    Prompt = Struct.new(:text)
+
+    # Convenience for subclasses: `prompt("...")` inside #execute returns a
+    # Prompt so the returned text is sent to the LLM.
+    def prompt(text)
+      Prompt.new(text)
+    end
+
     def name
       raise SkillNotImplementedError, "#{self.class}#name is not implemented"
     end

data/lib/yorishiro/skill_loader.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Yorishiro
+  # Auto-loads custom skills (slash commands) from skill directories such
+  # as ~/.yorishiro/skills and ./.yorishiro/skills. A skill file just
+  # defines Yorishiro::Skill subclasses — no registration call needed.
+  # New classes are detected by diffing the Skill class tree around the
+  # load and registered through Configuration#replace_skill, so the usual
+  # validation applies and later directories override same-name skills.
+  class SkillLoader
+    def initialize(configuration)
+      @configuration = configuration
+    end
+
+    def load_dir(dir)
+      return unless Dir.exist?(dir)
+
+      Dir.glob(File.join(dir, "*.rb")).each { |path| load_file(path) }
+    end
+
+    private
+
+    def load_file(path)
+      before = skill_classes
+      load path
+      (skill_classes - before).each { |klass| register(klass, path) }
+    rescue ConfigurationError
+      raise
+    rescue StandardError, SyntaxError => e
+      raise ConfigurationError, "Error loading skill file #{path}: #{e.message}"
+    end
+
+    def register(klass, path)
+      instance = klass.new
+      instance.name # abstract intermediate classes raise here — skip them
+      @configuration.replace_skill(instance)
+    rescue SkillNotImplementedError
+      nil
+    rescue StandardError => e
+      raise ConfigurationError, "Error registering skill #{klass} from #{path}: #{e.message}"
+    end
+
+    # Walk the whole subtree so skills inheriting from an intermediate
+    # base class (not directly from Skill) are found too.
+    def skill_classes
+      collect_subclasses(Skill)
+    end
+
+    def collect_subclasses(klass)
+      klass.subclasses.flat_map { |sub| [sub] + collect_subclasses(sub) }
+    end
+  end
+end

data/lib/yorishiro/sub_agent.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module Yorishiro
+  # Runs a delegated task in its own fresh Conversation so exploratory tool
+  # output never enters the parent conversation — only the final assistant
+  # text is returned. The caller decides which tools the subagent may use;
+  # Tools::Task passes read-only tools only, so no permission prompts fire.
+  class SubAgent
+    MAX_ITERATIONS = 15
+
+    SYSTEM_PROMPT = <<~PROMPT
+      You are a subagent handling a task delegated by a coding assistant.
+      Investigate using the available read-only tools, then reply with your
+      findings as plain text. Only your final message is returned to the
+      caller, so make it complete and self-contained. Do not ask questions —
+      nobody can answer them.
+    PROMPT
+
+    def initialize(provider:, tools:, output: $stdout,
+                   hooks: Yorishiro.configuration.hooks,
+                   max_iterations: MAX_ITERATIONS)
+      @provider = provider
+      @tools = tools
+      @output = output
+      @hooks = hooks
+      @max_iterations = max_iterations
+    end
+
+    # Run the agent loop for +prompt+ and return the final assistant text.
+    def run(prompt)
+      conversation = Conversation.new(system_prompt: SYSTEM_PROMPT)
+      conversation.add_message(:user, prompt)
+      last_content = nil
+
+      @max_iterations.times do |iteration|
+        manage_context!(conversation)
+
+        begin
+          result = @provider.chat(conversation, tools: @tools.map(&:definition))
+        rescue StandardError => e
+          # A failed completion must not throw away the investigation done so
+          # far — salvage it the same way the iteration limit does.
+          return provider_error_notice(last_content, e)
+        end
+        content = result[:content]
+        tool_calls = result[:tool_calls]
+
+        conversation.add_message(:assistant, content, tool_calls: tool_calls.empty? ? nil : tool_calls)
+        last_content = content unless content.to_s.empty?
+
+        return final_answer(content) if tool_calls.empty?
+
+        # Pending tool calls on the last iteration are pointless to execute —
+        # there is no follow-up completion to consume their results.
+        break if iteration == @max_iterations - 1
+
+        execute_tool_calls(conversation, tool_calls)
+      end
+
+      iteration_limit_notice(last_content)
+    end
+
+    private
+
+    # Same escalation as the CLI minus compaction (an extra LLM call is
+    # overkill for a short-lived loop) and minus the "[i]" notices — the
+    # subagent shrinks its context silently.
+    def manage_context!(conversation)
+      budget = @provider.context_budget_tokens
+      return unless budget
+
+      conversation.elide_old_tool_results!(max_tokens: budget)
+      conversation.trim_to_budget!(max_tokens: budget)
+    end
+
+    def final_answer(content)
+      content.to_s.empty? ? "The subagent returned no findings." : content
+    end
+
+    def iteration_limit_notice(last_content)
+      notice = "[Subagent reached the #{@max_iterations}-iteration limit without a final answer.]"
+      last_content ? "#{last_content}\n\n#{notice}" : notice
+    end
+
+    def provider_error_notice(last_content, error)
+      notice = "[Subagent stopped early after a provider error: #{error.message}]"
+      last_content ? "#{last_content}\n\n#{notice}" : notice
+    end
+
+    def execute_tool_calls(conversation, tool_calls)
+      tool_calls.each do |tc|
+        @output.puts "  [task] #{tc[:name]}(#{format_args(tc[:arguments])})"
+
+        denial = @hooks.run_before_tool_use(tc[:name], tc[:arguments])
+        if denial
+          conversation.add_tool_result(tool_call_id: tc[:id], content: "Tool call denied by hook: #{denial.reason}")
+          next
+        end
+
+        tool = @tools.find { |t| t.name == tc[:name] }
+        unless tool
+          conversation.add_tool_result(tool_call_id: tc[:id], content: "Error: Unknown tool '#{tc[:name]}'")
+          next
+        end
+
+        run_tool(conversation, tool, tc)
+      end
+    end
+
+    def run_tool(conversation, tool, tool_call)
+      output = tool.execute(**symbolize_keys(tool_call[:arguments]))
+      conversation.add_tool_result(
+        tool_call_id: tool_call[:id],
+        content: ToolResultCap.cap(output, budget: @provider.context_budget_tokens)
+      )
+      run_after_hooks(tool_call, output) # hooks (e.g. audit logs) see the full output
+    rescue StandardError => e
+      conversation.add_tool_result(tool_call_id: tool_call[:id], content: "Error: #{e.message}")
+    end
+
+    # after hooks are observational: a failure is warned about but never
+    # alters the already-recorded tool result.
+    def run_after_hooks(tool_call, output)
+      @hooks.run_after_tool_use(tool_call[:name], tool_call[:arguments], output)
+    rescue StandardError => e
+      @output.puts "[!] after_tool_use hook error: #{e.message}"
+    end
+
+    def format_args(args)
+      return "" unless args
+
+      args.map { |k, v| "#{k}: #{truncate(v.to_s, 50)}" }.join(", ")
+    end
+
+    def truncate(str, max)
+      str.length > max ? "#{str[0...max]}..." : str
+    end
+
+    def symbolize_keys(hash)
+      hash.transform_keys(&:to_sym)
+    end
+  end
+end

data/lib/yorishiro/tool.rb

@@ -37,5 +37,12 @@ module Yorishiro
     def configure(_options)
       # Override in subclasses to handle allow_tool options
     end
+
+    # Return a human-readable preview of what execute would do (e.g. a
+    # diff), shown in the permission prompt instead of the raw argument
+    # dump. Return nil to keep the default argument dump.
+    def preview(_arguments)
+      nil
+    end
   end
 end