pikuri-workspace 0.0.3

data/lib/pikuri/tool/grep.rb

@@ -0,0 +1,338 @@
+# frozen_string_literal: true
+
+module Pikuri
+  class Tool
+    # The +grep+ tool — content search across the workspace via
+    # +ripgrep+. Instantiating +Tool::Grep.new(workspace: ws)+ produces a
+    # tool whose {Tool#to_ruby_llm_tool} wiring is identical to any
+    # bundled tool's. Same shape as {Tool::Read} (workspace captured by
+    # the +execute+ closure, no confirmer — search is read-only).
+    #
+    # == ripgrep dependency
+    #
+    # Hard dependency: {.check_binaries!} runs in +initialize+ and raises
+    # if +rg+ isn't on +PATH+. Mirrors {Tool::Bash}'s posture for
+    # +bash+/+timeout+. We don't ship a Ruby fallback — replicating
+    # rg's Rust-regex dialect, glob handling, and +.gitignore+ parsing
+    # is a research-loop dead end. Failure message includes the install
+    # hint.
+    #
+    # == Argv
+    #
+    #   rg --line-number --color=never --no-heading --with-filename \
+    #      --hidden --max-columns=2000 --max-columns-preview \
+    #      --sort=path \
+    #      [-i] [--glob <g>] [--files-with-matches|--count-matches] \
+    #      -- <pattern> <relative-path-or-dot>
+    #
+    # * +--no-heading+ + +--with-filename+ → flat +path:line:content+ rows
+    #   regardless of whether the search target is a directory or a single
+    #   file (rg defaults to suppressing the filename for single-file
+    #   searches — we force it on for output consistency).
+    # * +--hidden+ → search dotfiles (still respects +.gitignore+).
+    # * +--max-columns=2000 --max-columns-preview+ → rg truncates lines
+    #   longer than {MAX_LINE_LENGTH} bytes server-side and appends a
+    #   preview marker, sparing us per-line truncation.
+    # * +--sort=path+ → deterministic output (single-threaded; fine for
+    #   typical repos under ~10k files). Makes specs assertable and gives
+    #   the model a stable order to scan.
+    # * Subprocess runs with +chdir: workspace.cwd+ and is *always* given
+    #   an explicit path argument. {Pikuri::Subprocess.spawn} uses
+    #   +popen2e+ which gives the child a piped (non-tty) stdin; rg's
+    #   default heuristic on no-path-arg-with-piped-stdin is to search
+    #   stdin (which we then close — yielding zero matches). Passing the
+    #   path argument explicitly bypasses the heuristic. Output paths
+    #   come back as +./...+ when the path is +.+; the leading +./+ is
+    #   stripped post-rg so the model sees clean workspace-relative paths.
+    #
+    # == Output modes
+    #
+    # * +content+ (default) — +path:line:content+ rows.
+    # * +files_with_matches+ — just file paths, one per line.
+    # * +count+ — +path:count+ per file.
+    #
+    # Use +files_with_matches+ to scope a broad search cheaply before
+    # paying tokens for +content+.
+    #
+    # == Truncation
+    #
+    # Total output is head-truncated to {MAX_BYTES} (head-only — grep
+    # tails usually carry less signal than the first matches; opposite
+    # bias from {Tool::Bash}). Cut at the last line boundary, with a
+    # marker reporting omitted bytes and the original total so the model
+    # knows how much it missed.
+    #
+    # == Exit codes
+    #
+    # * +0+ → matches; format with footer.
+    # * +1+ → no matches; return +"No matches for pattern '...'"+.
+    # * +2+ → rg error (bad regex, missing path); return +"Error: ripgrep: ..."+.
+    #
+    # == Refusals
+    #
+    # All returned as +"Error: ..."+ observations:
+    #
+    # * Empty +pattern+ → fast reject.
+    # * Unknown +output_mode+ → enum error listing valid values.
+    # * Path outside the workspace → caught from {Tool::Workspace::Error}.
+    # * Nonexistent path → +"Error: path not found: <path>"+.
+    class Grep < Tool
+      # @return [Integer] hard byte cap on combined rg output. Same value
+      #   as {Tool::Read::MAX_BYTES} so the two file-touching tools share
+      #   a budget shape.
+      MAX_BYTES = 50 * 1024
+
+      # @return [String] human-readable form of {MAX_BYTES} for the
+      #   truncation marker.
+      MAX_BYTES_LABEL = "#{MAX_BYTES / 1024} KB"
+
+      # @return [Integer] per-line cap passed to rg's +--max-columns+.
+      #   Long lines are truncated server-side with a preview marker.
+      MAX_LINE_LENGTH = 2000
+
+      # @return [Array<String>] valid +output_mode+ values.
+      OUTPUT_MODES = %w[content files_with_matches count].freeze
+
+      # @return [String] default +output_mode+.
+      DEFAULT_OUTPUT_MODE = 'content'
+
+      # Description shown to the LLM. opencode-shape (summary + +Usage:+
+      # bullets). Per-parameter constraints live in parameter
+      # descriptions.
+      #
+      # @return [String]
+      DESCRIPTION = <<~DESC
+        Search file contents for a regex pattern across the workspace.
+
+        Usage:
+        - Wraps `ripgrep` — regex syntax is rg's Rust-regex dialect (mostly PCRE-compatible; no lookbehind).
+        - Default search root is the workspace root; pass `path` to narrow to a file or subdirectory.
+        - Respects `.gitignore` — for unfiltered search use bash `rg --no-ignore <pattern>`.
+        - Use `glob` to filter by filename, e.g. `"*.rb"` or `"src/**/*.{ts,tsx}"`.
+        - `output_mode` controls verbosity: `content` (default, file:line:text), `files_with_matches` (paths only), `count` (matches per file).
+        - Use `files_with_matches` first to scope a broad search, then `content` (or `read`) to investigate — saves tokens.
+        - Output is truncated to #{MAX_BYTES_LABEL}; refine the pattern or narrow `path` if the response ends in a truncation marker.
+        - Long lines are truncated to #{MAX_LINE_LENGTH} chars with a preview marker; use `read` to see full lines.
+      DESC
+
+      # @param workspace [Tool::Workspace] captured for path resolution
+      #   and as +chdir+ for rg. All path arguments route through
+      #   +workspace.resolve_for_read+.
+      # @raise [RuntimeError] if +rg+ isn't on +PATH+; fail-loud at
+      #   construction rather than the first tool call.
+      # @return [Grep]
+      def initialize(workspace:)
+        Grep.send(:check_binaries!)
+        super(
+          name: 'grep',
+          description: DESCRIPTION,
+          parameters: Parameters.build { |p|
+            p.required_string :pattern,
+                              'Regex pattern to search for (rg Rust-regex ' \
+                              'dialect), e.g. "def\s+\w+" or "TODO".'
+            p.optional_string :path,
+                              'File or directory to search. Relative paths ' \
+                              'resolve against the workspace root. Defaults ' \
+                              'to the workspace root, e.g. "lib/" or "lib/foo.rb".'
+            p.optional_string :glob,
+                              'Filename glob to filter files, e.g. "*.rb" ' \
+                              'or "src/**/*.{ts,tsx}".'
+            p.optional_boolean :case_insensitive,
+                               'Match case-insensitively. Defaults to false, e.g. true.'
+            p.optional_string :output_mode,
+                              "One of #{OUTPUT_MODES.join(', ')}. Defaults to " \
+                              "#{DEFAULT_OUTPUT_MODE}, e.g. \"files_with_matches\"."
+          },
+          execute: lambda { |pattern:, path: nil, glob: nil,
+                            case_insensitive: false, output_mode: DEFAULT_OUTPUT_MODE|
+            Grep.search(workspace: workspace, pattern: pattern, path: path,
+                        glob: glob, case_insensitive: case_insensitive,
+                        output_mode: output_mode)
+          }
+        )
+      end
+
+      # Validate inputs, resolve the path against the workspace, spawn
+      # rg, and render the observation. Returns either the formatted
+      # results, a "no matches" string, or +"Error: ..."+.
+      #
+      # @param workspace [Tool::Workspace]
+      # @param pattern [String]
+      # @param path [String, nil]
+      # @param glob [String, nil]
+      # @param case_insensitive [Boolean]
+      # @param output_mode [String]
+      # @return [String]
+      def self.search(workspace:, pattern:, path:, glob:, case_insensitive:, output_mode:)
+        return 'Error: empty pattern.' if pattern.empty?
+        unless OUTPUT_MODES.include?(output_mode)
+          return "Error: output_mode must be one of #{OUTPUT_MODES.join(', ')}, " \
+                 "got #{output_mode.inspect}."
+        end
+
+        search_target = '.'
+        if path
+          resolved = workspace.resolve_for_read(path)
+          return "Error: path not found: #{path}" unless resolved.exist?
+
+          rel = resolved.relative_path_from(workspace.cwd).to_s
+          search_target = rel
+        end
+
+        argv = build_argv(pattern: pattern, glob: glob,
+                          case_insensitive: case_insensitive,
+                          output_mode: output_mode, path: search_target)
+
+        result = Pikuri::Subprocess.spawn(*argv, chdir: workspace.cwd.to_s).wait
+        exit_code = result.status.exitstatus
+
+        case exit_code
+        when 0
+          format_output(result.output, output_mode: output_mode,
+                        pattern: pattern, path: path)
+        when 1
+          no_match_message(pattern: pattern, path: path)
+        else
+          stderr = result.output.strip
+          stderr = "exited #{exit_code}" if stderr.empty?
+          "Error: ripgrep: #{stderr}"
+        end
+      rescue Tool::Workspace::Error => e
+        "Error: #{e.message}"
+      end
+
+      # Build the +rg+ argv. Path is always passed (defaults to +.+) —
+      # see the class header for why.
+      #
+      # @return [Array<String>]
+      def self.build_argv(pattern:, glob:, case_insensitive:, output_mode:, path:)
+        argv = [
+          'rg',
+          '--line-number',
+          '--color=never',
+          '--no-heading',
+          '--with-filename',
+          '--hidden',
+          "--max-columns=#{MAX_LINE_LENGTH}",
+          '--max-columns-preview',
+          '--sort=path'
+        ]
+        argv << '-i' if case_insensitive
+        argv.push('--glob', glob) if glob
+        case output_mode
+        when 'files_with_matches' then argv << '--files-with-matches'
+        when 'count'              then argv << '--count-matches'
+        end
+        argv.push('--', pattern, path)
+        argv
+      end
+      private_class_method :build_argv
+
+      # Render rg output: strip the +./+ prefix rg adds when path is
+      # +.+, head-truncate at {MAX_BYTES}, append a footer summarizing
+      # the result count.
+      #
+      # @return [String]
+      def self.format_output(raw, output_mode:, pattern:, path:)
+        cleaned = strip_dot_slash(raw)
+        content, truncation_marker = head_truncate(cleaned)
+        stripped = content.chomp
+
+        return no_match_message(pattern: pattern, path: path) if stripped.empty?
+
+        footer = build_footer(stripped, output_mode)
+        [stripped, '', footer + truncation_marker].join("\n")
+      end
+      private_class_method :format_output
+
+      # Strip leading +./+ from each line of rg output. rg emits this
+      # prefix when invoked with +.+ as the search path; we want clean
+      # workspace-relative paths regardless of whether the user passed a
+      # path or we defaulted to +.+.
+      #
+      # @return [String]
+      def self.strip_dot_slash(raw)
+        raw.gsub(/^\.\//, '')
+      end
+      private_class_method :strip_dot_slash
+
+      # Head-truncate +raw+ to {MAX_BYTES}, cutting at the last newline
+      # boundary so the final row is never partial. Returns the truncated
+      # content and a marker String (empty if no truncation).
+      #
+      # @return [Array(String, String)]
+      def self.head_truncate(raw)
+        total = raw.bytesize
+        return [raw, ''] if total <= MAX_BYTES
+
+        head = raw.byteslice(0, MAX_BYTES)
+        last_nl = head.rindex("\n")
+        head = head.byteslice(0, last_nl) if last_nl
+        omitted = total - head.bytesize
+        marker = "\n\n... [#{omitted} bytes omitted; total was #{total} bytes; " \
+                 'refine pattern or path] ...'
+        [head, marker]
+      end
+      private_class_method :head_truncate
+
+      # Compose a one-line footer summarizing the result. Format depends
+      # on +output_mode+; counts derive from rg's text output.
+      #
+      # @return [String]
+      def self.build_footer(content, output_mode)
+        lines = content.split("\n").reject(&:empty?)
+        case output_mode
+        when 'content'
+          files = lines.map { |l| l.split(':', 2).first }.uniq
+          "Found #{pluralize(lines.size, 'match', 'matches')} in " \
+            "#{pluralize(files.size, 'file', 'files')}."
+        when 'files_with_matches'
+          "Found #{pluralize(lines.size, 'file', 'files')}."
+        when 'count'
+          total = lines.sum { |l| Integer(l.split(':').last) }
+          "Found #{pluralize(total, 'match', 'matches')} in " \
+            "#{pluralize(lines.size, 'file', 'files')}."
+        end
+      end
+      private_class_method :build_footer
+
+      # @return [String] +"1 match"+ / +"2 matches"+
+      def self.pluralize(n, sing, plural)
+        "#{n} #{n == 1 ? sing : plural}"
+      end
+      private_class_method :pluralize
+
+      # @return [String]
+      def self.no_match_message(pattern:, path:)
+        base = "No matches for pattern '#{pattern}'"
+        base += " in #{path}" if path
+        "#{base}."
+      end
+      private_class_method :no_match_message
+
+      # Verify +rg+ is reachable on +PATH+. Routed through
+      # {Pikuri::Subprocess.spawn} to honor the subprocess seam.
+      # rg missing surfaces as +Errno::ENOENT+; an installed rg returns
+      # exit 0 from +--version+.
+      #
+      # @return [void]
+      # @raise [RuntimeError] if rg is missing
+      def self.check_binaries!
+        result = Pikuri::Subprocess.spawn('rg', '--version', chdir: '/').wait
+        return if result.status.success?
+
+        raise install_hint
+      rescue Errno::ENOENT
+        raise install_hint
+      end
+      private_class_method :check_binaries!
+
+      # @return [String]
+      def self.install_hint
+        "Tool::Grep requires 'rg' (ripgrep) on PATH; install via your " \
+          "distro's package manager (e.g. 'apt install ripgrep')."
+      end
+      private_class_method :install_hint
+    end
+  end
+end

data/lib/pikuri/tool/read.rb

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+module Pikuri
+  class Tool
+    # The +read+ tool, expressed as a {Tool} subclass: instantiating
+    # +Tool::Read.new(workspace: ws)+ produces a tool whose
+    # {Tool#to_ruby_llm_tool} wiring is identical to any bundled tool's,
+    # so ruby_llm sees nothing special about it. Same shape as
+    # {Tool::SubAgent} — workspace is captured by the +execute+ closure
+    # at construction.
+    #
+    # == Output format
+    #
+    # cat-n: each line is rendered as +"%6d\t%s"+ (six-column right-
+    # padded line number, tab, content). Chosen for breadth of training-
+    # data exposure: +cat -n+ output shows up across virtually every Unix
+    # tutorial and Stack Overflow answer, so even small local models
+    # recognize the shape. opencode's shorter +"<n>: <content>"+ format
+    # saves a few thousand tokens per 2K-line file but trades model
+    # familiarity; pi omits line numbers entirely (cheapest tokens, but
+    # the model loses the ability to cite ranges or pick {Edit}
+    # boundaries precisely).
+    #
+    # == Truncation rules
+    #
+    # Two independent limits, whichever fires first wins:
+    #
+    # * *Line limit* — {DEFAULT_LIMIT} lines (overridable via +limit+).
+    # * *Byte cap* — {MAX_BYTES} bytes of input content; not exposed as a
+    #   parameter. Bypassable in practice by paging via +offset+.
+    #
+    # Additionally, individual lines longer than {MAX_LINE_LENGTH} chars
+    # are truncated with {LINE_TRUNCATION_MARKER} appended; the model is
+    # told to reach for +grep+ to find content inside such files.
+    #
+    # == Refusals
+    #
+    # * Path outside the workspace → caught from
+    #   {Tool::Workspace::Error}, returned as +"Error: ..."+.
+    # * File not found, EACCES → +"Error: ..."+.
+    # * Path is a directory → +"Error: ... use the glob tool"+, keeping
+    #   directory listing as the glob tool's responsibility (Step 9).
+    # * Binary content → sniffed from the first {BINARY_SAMPLE_BYTES} of
+    #   the file: any +NUL+ byte, or more than {BINARY_NONPRINTABLE_THRESHOLD}
+    #   non-printable bytes (control chars outside +\t \n \v \f \r+),
+    #   triggers refusal. Catches images, PDFs, archives, and compiled
+    #   artifacts without an extension list to maintain.
+    # * Offset past EOF → +"Error: offset N is beyond end of file (M lines total)"+.
+    class Read < Tool
+      # @return [Integer] default value of the +limit+ parameter (number
+      #   of lines to read per call).
+      DEFAULT_LIMIT = 2000
+
+      # @return [Integer] per-line character cap; longer lines are
+      #   truncated with {LINE_TRUNCATION_MARKER}.
+      MAX_LINE_LENGTH = 2000
+
+      # @return [String] suffix appended to lines truncated by
+      #   {MAX_LINE_LENGTH}.
+      LINE_TRUNCATION_MARKER = "... (line truncated to #{MAX_LINE_LENGTH} chars)"
+
+      # @return [Integer] hard byte cap on input content collected per
+      #   call. Counted on the line bytes (plus one for the joining
+      #   newline); the rendered output is slightly larger due to the
+      #   per-line +"%6d\t"+ prefix.
+      MAX_BYTES = 50 * 1024
+
+      # @return [String] human-readable form of {MAX_BYTES} for the
+      #   continuation marker.
+      MAX_BYTES_LABEL = "#{MAX_BYTES / 1024} KB"
+
+      # @return [Integer] number of bytes sampled from the start of the
+      #   file for binary-content detection.
+      BINARY_SAMPLE_BYTES = 4096
+
+      # @return [Float] fraction of the sample that may be non-printable
+      #   before the file is classified as binary. Matches opencode's
+      #   30%.
+      BINARY_NONPRINTABLE_THRESHOLD = 0.30
+
+      # Description shown to the LLM. Follows the opencode-shape (summary
+      # + +Usage:+ bullets) prescribed by the project's tool-description
+      # convention. Per-parameter constraints (defaults, format) live in
+      # the parameter descriptions, not here.
+      #
+      # @return [String]
+      DESCRIPTION = <<~DESC
+        Read a file from the workspace and return its contents with line numbers.
+
+        Usage:
+        - Output is line-numbered in `cat -n` style so subsequent edits can reference exact line numbers.
+        - Use `offset` and `limit` to page through large files; when the response ends in `Use offset=N to continue`, call again with that offset.
+        - Lines longer than #{MAX_LINE_LENGTH} chars are truncated with a marker — use `grep` for content inside such files.
+        - Binary files (images, PDFs, archives, compiled artifacts) are refused; this tool reads text only.
+        - Directories are refused — use the `glob` tool to list files.
+        - If unsure of the path, use `glob` first to look up filenames.
+        - Avoid tiny repeated slices — if you need more context, read a larger window.
+      DESC
+
+      # @param workspace [Tool::Workspace] captured for path resolution;
+      #   all reads route through +workspace.resolve_for_read+.
+      # @return [Read]
+      def initialize(workspace:)
+        super(
+          name: 'read',
+          description: DESCRIPTION,
+          parameters: Parameters.build { |p|
+            p.required_string :path,
+                              'Path to the file to read. Relative paths ' \
+                              'resolve against the workspace root, e.g. ' \
+                              '"lib/foo.rb" or "/abs/path/to/file.txt".'
+            p.optional_integer :offset,
+                               'Line number to start reading from (1-indexed). ' \
+                               "Defaults to 1, e.g. 200."
+            p.optional_integer :limit,
+                               'Maximum number of lines to read. Defaults to ' \
+                               "#{DEFAULT_LIMIT}, e.g. 500."
+          },
+          execute: ->(path:, offset: 1, limit: DEFAULT_LIMIT) {
+            Read.read(workspace: workspace, path: path, offset: offset, limit: limit)
+          }
+        )
+      end
+
+      # Resolve +path+ against +workspace+, refuse directories / binaries /
+      # missing files, and return either the cat-n-formatted slice or an
+      # +"Error: ..."+ observation.
+      #
+      # @param workspace [Tool::Workspace]
+      # @param path [String] raw path as supplied by the LLM
+      # @param offset [Integer] 1-indexed line number to start at
+      # @param limit [Integer] maximum lines to return
+      # @return [String] tool observation
+      def self.read(workspace:, path:, offset:, limit:)
+        return "Error: offset must be >= 1, got #{offset}" if offset < 1
+        return "Error: limit must be >= 1, got #{limit}"   if limit < 1
+
+        resolved = workspace.resolve_for_read(path)
+        return "Error: file not found: #{path}" unless resolved.exist?
+        return "Error: #{path} is a directory; use the glob tool to list files." if resolved.directory?
+
+        sample = read_sample(resolved)
+        return "Error: cannot read binary file: #{path}" if binary?(sample)
+
+        format_slice(path: path, resolved: resolved, offset: offset, limit: limit)
+      rescue Tool::Workspace::Error => e
+        "Error: #{e.message}"
+      rescue Errno::EACCES => e
+        "Error: cannot read #{path}: #{e.message}"
+      end
+
+      # Read up to {BINARY_SAMPLE_BYTES} of the file in binary mode for
+      # the {.binary?} sniff. Returns an empty String for an empty file
+      # (which {.binary?} treats as not-binary).
+      #
+      # @param resolved [Pathname]
+      # @return [String] raw bytes (ASCII-8BIT encoding)
+      def self.read_sample(resolved)
+        resolved.open('rb') { |io| io.read(BINARY_SAMPLE_BYTES) || +'' }
+      end
+      private_class_method :read_sample
+
+      # Heuristic binary classifier matching opencode's: any NUL byte
+      # forces +true+; otherwise count bytes outside the printable +\t \n
+      # \v \f \r+ + ASCII-32..126 range and ratio against the sample
+      # size. UTF-8 continuation bytes (0x80-0xBF) are >127 so they sit
+      # outside the non-printable ranges and pass through unflagged,
+      # letting UTF-8 text read fine.
+      #
+      # Public because {Tool::Edit} reuses it to refuse binary targets —
+      # if Edit accepted a binary file the model has no way to have read,
+      # it could corrupt bytes the model never inspected. Same sniff, same
+      # threshold, one definition.
+      #
+      # @param bytes [String] sample bytes
+      # @return [Boolean]
+      def self.binary?(bytes)
+        return false if bytes.empty?
+
+        non_printable = 0
+        bytes.each_byte do |b|
+          return true if b.zero?
+
+          non_printable += 1 if b < 9 || (b > 13 && b < 32)
+        end
+        non_printable.to_f / bytes.bytesize > BINARY_NONPRINTABLE_THRESHOLD
+      end
+
+      # Stream the file line-by-line, collect at most +limit+ lines
+      # starting at +offset+, and stop early if {MAX_BYTES} is reached.
+      # We keep counting lines past the collection window so the trailer
+      # can report total line count when the line limit (not the byte
+      # cap) was the stopping criterion — same trick opencode uses.
+      #
+      # @return [String]
+      def self.format_slice(path:, resolved:, offset:, limit:)
+        start_index   = offset - 1
+        collected     = []
+        total_lines   = 0
+        bytes         = 0
+        byte_cap_hit  = false
+        has_more      = false
+
+        resolved.each_line do |raw|
+          total_lines += 1
+          next if total_lines <= start_index
+
+          if collected.length >= limit
+            has_more = true
+            next
+          end
+
+          line = raw.chomp
+          if line.length > MAX_LINE_LENGTH
+            line = line[0, MAX_LINE_LENGTH] + LINE_TRUNCATION_MARKER
+          end
+
+          size = line.bytesize + 1 # +1 for the joining newline
+          if bytes + size > MAX_BYTES
+            byte_cap_hit = true
+            has_more = true
+            break
+          end
+
+          collected << line
+          bytes += size
+        end
+
+        return '(Empty file)' if total_lines.zero?
+
+        if start_index >= total_lines
+          return "Error: offset #{offset} is beyond end of file (#{total_lines} lines total)"
+        end
+
+        last_line = offset + collected.length - 1
+        body = collected.each_with_index.map { |line, i| format("%6d\t%s", i + offset, line) }.join("\n")
+
+        trailer =
+          if byte_cap_hit
+            "(Output capped at #{MAX_BYTES_LABEL}. Showing lines #{offset}-#{last_line}. " \
+              "Use offset=#{last_line + 1} to continue.)"
+          elsif has_more
+            "(Showing lines #{offset}-#{last_line} of #{total_lines}. " \
+              "Use offset=#{last_line + 1} to continue.)"
+          else
+            "(End of file - total #{total_lines} lines)"
+          end
+
+        "#{body}\n\n#{trailer}"
+      end
+      private_class_method :format_slice
+    end
+  end
+end