yorishiro 0.1.0 → 0.2.0

data/lib/yorishiro/tool_result_cap.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Yorishiro
+  # Caps a tool result before it enters a conversation so a single huge
+  # output (a whole file, a big command dump) cannot exhaust a small
+  # context window. Scaled to the provider budget when one is known.
+  # Shared by the CLI agent loop and subagents.
+  module ToolResultCap
+    # Tool-result size caps used when the provider reports no context
+    # budget (cloud models) and as the floor when it does.
+    DEFAULT_TOOL_RESULT_CHARS = 30_000
+    MIN_TOOL_RESULT_CHARS = 2_000
+
+    module_function
+
+    def cap(output, budget:)
+      limit = max_chars(budget)
+      return output if output.to_s.length <= limit
+
+      "#{output[0...limit]}\n... (tool output truncated: showing #{limit} of #{output.length} characters. " \
+        "Narrow the request — offset/limit, a glob, or a more specific pattern — to see the rest.)"
+    end
+
+    # One tool result may take at most a quarter of the context budget.
+    def max_chars(budget)
+      return DEFAULT_TOOL_RESULT_CHARS unless budget
+
+      [budget * Conversation::CHARS_PER_TOKEN / 4, MIN_TOOL_RESULT_CHARS].max
+    end
+  end
+end

data/lib/yorishiro/tools/edit_file.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Yorishiro
+  module Tools
+    class EditFile < Tool
+      def name
+        "edit_file"
+      end
+
+      def description
+        "Replace an exact string in a file. old_string must match the file content exactly " \
+          "(including whitespace and indentation) and must be unique unless replace_all is true."
+      end
+
+      def parameters
+        {
+          type: "object",
+          properties: {
+            path: { type: "string", description: "The file path to edit" },
+            old_string: { type: "string", description: "The exact text to replace" },
+            new_string: { type: "string", description: "The text to replace it with" },
+            replace_all: { type: "boolean", description: "Replace all occurrences (default: false)" }
+          },
+          required: %w[path old_string new_string]
+        }
+      end
+
+      def execute(**params)
+        path = params[:path] || params["path"]
+        old_string = params[:old_string] || params["old_string"]
+        new_string = params[:new_string] || params["new_string"]
+        replace_all = params[:replace_all] || params["replace_all"] || false
+
+        raise "File not found: #{path}" unless File.exist?(path)
+        raise "Not a file: #{path}" unless File.file?(path)
+
+        content = File.read(path)
+        new_content, count = apply_edit(content, old_string, new_string, replace_all, path)
+
+        File.write(path, new_content)
+        "Successfully replaced #{count} occurrence(s) in #{path}"
+      end
+
+      def permission_check(_arguments)
+        :ask
+      end
+
+      def preview(arguments)
+        path = arguments[:path] || arguments["path"]
+        old_string = arguments[:old_string] || arguments["old_string"]
+        new_string = arguments[:new_string] || arguments["new_string"]
+        replace_all = arguments[:replace_all] || arguments["replace_all"] || false
+        return nil unless path && old_string && new_string
+        return nil unless File.file?(path)
+
+        content = File.read(path)
+        new_content, = apply_edit(content, old_string, new_string, replace_all, path)
+        Diff.unified(content, new_content, path: path)
+      rescue StandardError
+        nil
+      end
+
+      private
+
+      def apply_edit(content, old_string, new_string, replace_all, path)
+        raise "old_string and new_string are identical. Provide a different new_string." if old_string == new_string
+
+        count = content.scan(old_string).length
+        if count.zero?
+          raise "old_string not found in #{path}. Read the file first and copy the exact text, " \
+                "including whitespace and indentation."
+        end
+        if count > 1 && !replace_all
+          raise "old_string appears #{count} times in #{path}. Add surrounding lines to make it unique, " \
+                "or set replace_all: true."
+        end
+
+        # Block form so backreference sequences (\1, \\) in new_string are
+        # written literally instead of being interpreted.
+        new_content = replace_all ? content.gsub(old_string) { new_string } : content.sub(old_string) { new_string }
+        [new_content, replace_all ? count : 1]
+      rescue ArgumentError => e
+        raise "Cannot edit #{path}: #{e.message}"
+      end
+    end
+  end
+end

data/lib/yorishiro/tools/execute_command.rb

@@ -5,6 +5,13 @@ require "open3"
 module Yorishiro
   module Tools
     class ExecuteCommand < Tool
+      # Commands run via `sh -c`, so these characters can chain or inject
+      # additional commands (`;`, `&`, `|`, newlines), substitute commands
+      # (`$`, backtick, `(`, `)`), or redirect files (`<`, `>`). Commands
+      # containing any of them never auto-match allow_commands and always
+      # fall back to the interactive permission prompt.
+      SHELL_METACHARACTERS = /[;&|`$<>()\n\r]/
+
       def initialize
         super
         @allow_commands = []
@@ -62,6 +69,7 @@ module Yorishiro
 
       def command_allowed?(command)
         return true if @session_allowed.include?(command)
+        return false if command.match?(SHELL_METACHARACTERS)
 
         @allow_commands.any? { |pattern| File.fnmatch(pattern, command) }
       end

data/lib/yorishiro/tools/exit_plan_mode.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Yorishiro
+  module Tools
+    # A plan-mode-only tool the model calls to signal that it has finished
+    # researching and is ready to present its implementation plan. Calling it
+    # is what breaks the plan loop, so the model has an explicit way to stop
+    # reading files instead of looping on read-only tools forever.
+    class ExitPlanMode < Tool
+      def read_only?
+        true
+      end
+
+      def name
+        "exit_plan_mode"
+      end
+
+      def description
+        "Call this tool once you have finished researching and are ready to " \
+          "present your implementation plan to the user for approval. Pass the " \
+          "complete plan as the `plan` argument. As soon as you understand the " \
+          "task, STOP calling read-only tools (read_file, list_files) and call " \
+          "this tool instead."
+      end
+
+      def parameters
+        {
+          type: "object",
+          properties: {
+            plan: { type: "string", description: "The complete implementation plan as markdown text" }
+          },
+          required: ["plan"]
+        }
+      end
+
+      def execute(**params)
+        params[:plan] || params["plan"] || ""
+      end
+    end
+  end
+end

data/lib/yorishiro/tools/grep.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Yorishiro
+  module Tools
+    class Grep < Tool
+      MAX_RESULTS = 100
+      EXCLUDED_DIRS = %w[.git node_modules vendor tmp].freeze
+      BINARY_CHECK_BYTES = 8_000
+      MAX_LINE_LENGTH = 250
+
+      def read_only?
+        true
+      end
+
+      def name
+        "grep"
+      end
+
+      def description
+        "Search file contents recursively with a Ruby regular expression. " \
+          "Returns matches as 'file:line:content'. Hidden files and directories (e.g. .git) are skipped."
+      end
+
+      def parameters
+        {
+          type: "object",
+          properties: {
+            pattern: { type: "string", description: "Ruby regular expression to search for" },
+            path: { type: "string", description: "Directory to search in (default: current directory)" },
+            glob: { type: "string", description: "Glob pattern to filter files (e.g., '*.rb')" }
+          },
+          required: ["pattern"]
+        }
+      end
+
+      def execute(**params)
+        pattern = params[:pattern] || params["pattern"]
+        path = params[:path] || params["path"] || "."
+        glob = params[:glob] || params["glob"]
+
+        regexp = build_regexp(pattern)
+        raise "Directory not found: #{path}" unless Dir.exist?(path)
+
+        matches, truncated = search(regexp, path, glob)
+        format_results(matches, truncated, pattern)
+      end
+
+      private
+
+      def build_regexp(pattern)
+        Regexp.new(pattern)
+      rescue RegexpError => e
+        raise "Invalid regular expression: #{e.message}"
+      end
+
+      def search(regexp, path, glob)
+        matches = []
+
+        target_files(path, glob).each do |file|
+          scan_file(file, regexp) do |line_number, line|
+            return [matches, true] if matches.length >= MAX_RESULTS
+
+            matches << "#{file}:#{line_number}:#{line}"
+          end
+        end
+
+        [matches, false]
+      end
+
+      # Dir.glob without FNM_DOTMATCH already skips dotfiles and dot
+      # directories; EXCLUDED_DIRS guards against globs that reach into
+      # them explicitly (e.g. vendored or dependency directories).
+      def target_files(path, glob)
+        glob_pattern = File.join(path, glob ? "**/#{glob}" : "**/*")
+        Dir.glob(glob_pattern).select do |file|
+          File.file?(file) && !excluded?(file, path)
+        end
+      end
+
+      # Only path components below the search root count as excluded, so
+      # searching inside e.g. /tmp/project still works.
+      def excluded?(file, base)
+        relative = file.delete_prefix(File.join(base, ""))
+        relative.split(File::SEPARATOR).any? { |part| EXCLUDED_DIRS.include?(part) }
+      end
+
+      def scan_file(file, regexp)
+        return if binary?(file)
+
+        File.foreach(file).with_index(1) do |line, line_number|
+          line = line.scrub.chomp
+          yield line_number, truncate_line(line) if regexp.match?(line)
+        end
+      rescue SystemCallError
+        # Unreadable files are skipped.
+      end
+
+      def binary?(file)
+        chunk = File.binread(file, BINARY_CHECK_BYTES)
+        chunk&.include?("\0")
+      rescue SystemCallError
+        true
+      end
+
+      def truncate_line(line)
+        line.length > MAX_LINE_LENGTH ? "#{line[0...MAX_LINE_LENGTH]}..." : line
+      end
+
+      def format_results(matches, truncated, pattern)
+        return "No matches found for pattern: #{pattern}" if matches.empty?
+
+        result = matches.join("\n")
+        result += "\n... (truncated: showing first #{MAX_RESULTS} matches)" if truncated
+        result
+      end
+    end
+  end
+end

data/lib/yorishiro/tools/list_files.rb

@@ -32,14 +32,16 @@ module Yorishiro
 
         raise "Directory not found: #{path}" unless Dir.exist?(path)
 
-        if pattern
-          glob_path = File.join(path, pattern)
-          files = Dir.glob(glob_path)
-        else
-          files = Dir.children(path).sort
-        end
-
-        files.map { |f| File.directory?(f) ? "#{f}/" : f }.join("\n")
+        entries = if pattern
+                    # Glob results already carry the path prefix.
+                    Dir.glob(File.join(path, pattern)).map { |f| [f, f] }
+                  else
+                    # Dir.children returns bare names — resolve them against
+                    # +path+, not the process cwd, when checking for directories.
+                    Dir.children(path).sort.map { |name| [name, File.join(path, name)] }
+                  end
+
+        entries.map { |display, full| File.directory?(full) ? "#{display}/" : display }.join("\n")
       end
     end
   end

data/lib/yorishiro/tools/read_file.rb

@@ -3,6 +3,12 @@
 module Yorishiro
   module Tools
     class ReadFile < Tool
+      # Cap how much of a file one call can return. Small local-model
+      # context windows (e.g. Ollama with num_ctx 8192) are exhausted by a
+      # single whole-file dump, so large files must be paged instead.
+      MAX_LINES = 200
+      MAX_LINE_LENGTH = 500
+
       def read_only?
         true
       end
@@ -12,7 +18,8 @@ module Yorishiro
       end
 
       def description
-        "Read the contents of a file at the specified path. Optionally specify offset and limit for partial reads."
+        "Read the contents of a file at the specified path. Returns at most #{MAX_LINES} lines per call; " \
+          "use offset and limit to page through larger files."
       end
 
       def parameters
@@ -21,7 +28,7 @@ module Yorishiro
           properties: {
             path: { type: "string", description: "The file path to read" },
             offset: { type: "integer", description: "Line number to start reading from (0-based)" },
-            limit: { type: "integer", description: "Maximum number of lines to read" }
+            limit: { type: "integer", description: "Maximum number of lines to read (capped at #{MAX_LINES})" }
           },
           required: ["path"]
         }
@@ -29,21 +36,32 @@ module Yorishiro
 
       def execute(**params)
         path = params[:path] || params["path"]
-        offset = (params[:offset] || params["offset"])&.to_i
+        offset = (params[:offset] || params["offset"]).to_i
         limit = (params[:limit] || params["limit"])&.to_i
+        limit = limit.nil? ? MAX_LINES : [limit, MAX_LINES].min
 
         raise "File not found: #{path}" unless File.exist?(path)
         raise "Not a file: #{path}" unless File.file?(path)
 
         lines = File.readlines(path)
+        selected = lines[offset, limit] || []
+
+        output = selected.each_with_index.map { |line, i| "#{offset + i + 1}: #{truncate_line(line)}" }.join
+        output + paging_notice(lines.length, offset, selected.length)
+      end
+
+      private
+
+      def truncate_line(line)
+        return line if line.chomp.length <= MAX_LINE_LENGTH
+
+        "#{line.chomp[0...MAX_LINE_LENGTH]}... (line truncated)\n"
+      end
 
-        if offset || limit
-          offset ||= 0
-          limit ||= lines.length
-          lines = lines[offset, limit] || []
-        end
+      def paging_notice(total, offset, shown)
+        return "" unless total > offset + shown
 
-        lines.each_with_index.map { |line, i| "#{(offset || 0) + i + 1}: #{line}" }.join
+        "... (file has #{total} lines; showing #{offset + 1}-#{offset + shown}. Use offset/limit to read more.)"
       end
     end
   end

data/lib/yorishiro/tools/task.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Yorishiro
+  module Tools
+    class Task < Tool
+      # Read-only: the subagent only ever receives read-only tools, so a
+      # task can never mutate anything.
+      def read_only?
+        true
+      end
+
+      def name
+        "task"
+      end
+
+      def description
+        "Delegate a read-only research task to a subagent with its own fresh " \
+          "context window. The subagent can read files, list files, and grep, " \
+          "and returns a text summary of its findings. Use it for exploratory " \
+          "work (finding where something is defined, summarizing several files) " \
+          "to keep your own context small. The subagent cannot see this " \
+          "conversation, so the prompt must be complete and self-contained."
+      end
+
+      def parameters
+        {
+          type: "object",
+          properties: {
+            description: {
+              type: "string",
+              description: "Short (3-7 word) label for the task"
+            },
+            prompt: {
+              type: "string",
+              description: "Complete, self-contained instructions: what to investigate and what to report back"
+            }
+          },
+          required: ["prompt"]
+        }
+      end
+
+      # Called by the CLI so the subagent reuses the session's provider and
+      # prints its progress to the session's output.
+      def attach(provider:, output:)
+        @provider = provider
+        @output = output
+      end
+
+      def execute(**params)
+        prompt = params[:prompt] || params["prompt"]
+        raise "prompt is required" if prompt.to_s.strip.empty?
+
+        SubAgent.new(provider: provider, tools: child_tools, output: output).run(prompt)
+      end
+
+      private
+
+      def provider
+        @provider ||= Provider.build(Yorishiro.configuration)
+      end
+
+      def output
+        @output || $stdout
+      end
+
+      # Read-only tools never prompt for permission, so the subagent loop
+      # runs unattended. The task tool itself is excluded so subagents
+      # cannot nest.
+      def child_tools
+        Yorishiro.configuration.allowed_tools.select(&:read_only?).grep_v(Task)
+      end
+    end
+  end
+end

data/lib/yorishiro/tools/write_file.rb

@@ -36,6 +36,15 @@ module Yorishiro
       def permission_check(_arguments)
         :ask
       end
+
+      def preview(arguments)
+        path = arguments[:path] || arguments["path"]
+        content = arguments[:content] || arguments["content"]
+        return nil unless path && content
+
+        old_content = File.file?(path) ? File.read(path) : ""
+        Diff.unified(old_content, content, path: path)
+      end
     end
   end
 end

data/lib/yorishiro/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Yorishiro
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/yorishiro.rb

@@ -6,18 +6,30 @@ require "securerandom"
 
 require_relative "yorishiro/version"
 require_relative "yorishiro/tool"
+require_relative "yorishiro/diff"
 require_relative "yorishiro/skill"
+require_relative "yorishiro/skill_loader"
+require_relative "yorishiro/hooks"
 require_relative "yorishiro/configuration"
 require_relative "yorishiro/conversation"
+require_relative "yorishiro/tool_result_cap"
+require_relative "yorishiro/input_history"
+require_relative "yorishiro/session_store"
+require_relative "yorishiro/session_resume"
+require_relative "yorishiro/compactor"
 require_relative "yorishiro/provider/base"
 require_relative "yorishiro/provider/anthropic"
 require_relative "yorishiro/provider/open_ai"
 require_relative "yorishiro/provider/ollama"
+require_relative "yorishiro/sub_agent"
 require_relative "yorishiro/tools/read_file"
 require_relative "yorishiro/tools/write_file"
+require_relative "yorishiro/tools/edit_file"
 require_relative "yorishiro/tools/list_files"
+require_relative "yorishiro/tools/grep"
 require_relative "yorishiro/tools/execute_command"
-require_relative "yorishiro/mcp/stdio_transport"
+require_relative "yorishiro/tools/exit_plan_mode"
+require_relative "yorishiro/tools/task"
 require_relative "yorishiro/mcp/tool"
 require_relative "yorishiro/mcp/server_manager"
 require_relative "yorishiro/cli"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yorishiro
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - S-H-GAMELINKS
@@ -10,7 +10,7 @@ cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: json
+  name: base64
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -24,7 +24,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: mcp
+  name: json
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -37,6 +37,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: mcp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
 - !ruby/object:Gem::Dependency
   name: net-http
   requirement: !ruby/object:Gem::Requirement
@@ -96,23 +110,37 @@ files:
 - Rakefile
 - docs/en/README.md
 - docs/ja/README.md
+- docs/ja/how_to_create_skills.md
+- docs/ja/ollama_setup.md
 - exe/yorishiro
 - lib/yorishiro.rb
 - lib/yorishiro/cli.rb
+- lib/yorishiro/compactor.rb
 - lib/yorishiro/configuration.rb
 - lib/yorishiro/conversation.rb
+- lib/yorishiro/diff.rb
+- lib/yorishiro/hooks.rb
+- lib/yorishiro/input_history.rb
 - lib/yorishiro/mcp/server_manager.rb
-- lib/yorishiro/mcp/stdio_transport.rb
 - lib/yorishiro/mcp/tool.rb
 - lib/yorishiro/provider/anthropic.rb
 - lib/yorishiro/provider/base.rb
 - lib/yorishiro/provider/ollama.rb
 - lib/yorishiro/provider/open_ai.rb
+- lib/yorishiro/session_resume.rb
+- lib/yorishiro/session_store.rb
 - lib/yorishiro/skill.rb
+- lib/yorishiro/skill_loader.rb
+- lib/yorishiro/sub_agent.rb
 - lib/yorishiro/tool.rb
+- lib/yorishiro/tool_result_cap.rb
+- lib/yorishiro/tools/edit_file.rb
 - lib/yorishiro/tools/execute_command.rb
+- lib/yorishiro/tools/exit_plan_mode.rb
+- lib/yorishiro/tools/grep.rb
 - lib/yorishiro/tools/list_files.rb
 - lib/yorishiro/tools/read_file.rb
+- lib/yorishiro/tools/task.rb
 - lib/yorishiro/tools/write_file.rb
 - lib/yorishiro/version.rb
 - sig/yorishiro.rbs
@@ -139,7 +167,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.1.0.dev
+rubygems_version: 4.0.16
 specification_version: 4
 summary: A Ruby CLI LLM agent with tool execution, MCP support, and multi-provider
   backends