kward 0.70.0 → 0.72.0

data/lib/kward/workspace.rb

@@ -20,7 +20,7 @@ module Kward
     MAX_FILE_BYTES = 256 * 1024
     MAX_READ_OUTPUT_BYTES = 50 * 1024
     MAX_READ_OUTPUT_LINES = 2_000
-    MAX_COMMAND_OUTPUT_BYTES = 20 * 1024
+    MAX_COMMAND_OUTPUT_BYTES = 128 * 1024
     MAX_EDIT_DIFF_BYTES = 8 * 1024
     DEFAULT_COMMAND_TIMEOUT_SECONDS = 30
 
@@ -54,7 +54,7 @@ module Kward
     # The returned string is user/model-facing and includes continuation notices
     # when output is truncated. Errors are returned as `"Error: ..."` strings so
     # tool calls can be persisted in the conversation without raising.
-    def read_file(path, offset: nil, limit: nil)
+    def read_file(path, offset: nil, limit: nil, mode: nil, max_bytes: nil)
       resolved = workspace_path(path)
       return "Error: not a file: #{path}" unless File.file?(resolved)
 
@@ -64,7 +64,40 @@ module Kward
       content = File.read(resolved)
       return "Error: not a text file: #{path}" if binary_content?(content)
 
-      read_file_slice(content, offset: offset, limit: limit)
+      read_mode = normalize_read_mode(mode)
+      return read_mode if read_mode.is_a?(String)
+
+      output_budget = read_output_budget(max_bytes)
+      return output_budget if output_budget.is_a?(String)
+
+      case read_mode
+      when :outline
+        file_structure_summary(path, content)
+      when :preview
+        read_file_slice(content, offset: offset, limit: limit || 120, max_bytes: output_budget)
+      when :range
+        read_file_slice(content, offset: offset, limit: limit, max_bytes: output_budget)
+      when :full
+        read_file_slice(content, offset: offset, limit: limit, max_bytes: output_budget)
+      else
+        large_file_outline_response(path, content, offset: offset, limit: limit) || read_file_slice(content, offset: offset, limit: limit, max_bytes: output_budget)
+      end
+    rescue SecurityError, Errno::ENOENT => e
+      "Error: #{e.message}"
+    end
+
+    # Returns a compact outline of recognizable source-code declarations.
+    def summarize_file_structure(path)
+      resolved = workspace_path(path)
+      return "Error: not a file: #{path}" unless File.file?(resolved)
+
+      size = File.size(resolved)
+      return "Error: file too large: #{path} is #{size} bytes; limit is #{@max_file_bytes} bytes" if size > @max_file_bytes
+
+      content = File.read(resolved)
+      return "Error: not a text file: #{path}" if binary_content?(content)
+
+      file_structure_summary(path, content)
     rescue SecurityError, Errno::ENOENT => e
       "Error: #{e.message}"
     end
@@ -196,7 +229,115 @@ module Kward
       Pathname.new(path).relative_path_from(@root).to_s
     end
 
-    def read_file_slice(content, offset:, limit:)
+    def large_file_outline_response(path, content, offset:, limit:)
+      return nil unless offset.nil? && limit.nil?
+      lines = content.split("\n", -1)
+      return nil unless lines.length > @max_read_output_lines || content.bytesize > @max_read_output_bytes
+
+      outline = source_outline(lines)
+      return nil if outline.empty?
+
+      preview_limit = [120, @max_read_output_lines].min
+      preview = lines.first(preview_limit).join("\n")
+      [
+        "File has #{lines.length} lines (#{content.bytesize} bytes). Showing an outline and the first #{preview_limit} lines to reduce model context.",
+        "",
+        "Outline:",
+        outline.join("\n"),
+        "",
+        "First #{preview_limit} lines:",
+        preview,
+        "",
+        "[Use read_file with mode=\"range\", offset=#{preview_limit + 1}, and limit to continue; mode=\"outline\" for only the outline; or request a specific section from the outline.]"
+      ].join("\n")
+    end
+
+    def file_structure_summary(path, content)
+      lines = content.split("\n", -1)
+      outline = source_outline(lines)
+      return "No recognizable source structure found in #{path}." if outline.empty?
+
+      (["# File structure: #{path}", "- Lines: #{lines.length}", "- Bytes: #{content.bytesize}", "", "## Outline"] + outline).join("\n")
+    end
+
+    def source_outline(lines)
+      entries = source_outline_entries(lines)
+      entries.first(80).map do |entry|
+        range = entry[:end_line] && entry[:end_line] != entry[:line] ? " (range #{entry[:line]}-#{entry[:end_line]}, #{entry[:kind]})" : " (#{entry[:kind]})"
+        "line #{entry[:line]}: #{'  ' * [entry[:indent] / 2, 6].min}#{entry[:signature]}#{range}"
+      end
+    end
+
+    def source_outline_entries(lines)
+      candidates = []
+      lines.each_with_index do |line, index|
+        declaration = source_declaration(line.strip)
+        next unless declaration
+
+        candidates << declaration.merge(line: index + 1, indent: line[/\A\s*/].to_s.length)
+      end
+      candidates.each_with_index do |entry, index|
+        following = candidates[(index + 1)..]&.find { |candidate| candidate[:indent] <= entry[:indent] }
+        entry[:end_line] = following ? following[:line] - 1 : last_content_line(lines)
+      end
+      candidates
+    end
+
+    def source_declaration(stripped)
+      case stripped
+      when /\A(module)\s+(.+)/
+        { kind: "module", signature: stripped }
+      when /\A(class)\s+(.+)/
+        { kind: "class", signature: stripped }
+      when /\A(async\s+def|def)\s+(.+)/
+        { kind: "function", signature: stripped }
+      when /\A(export\s+)?(async\s+)?function\s+(.+)/
+        { kind: "function", signature: stripped }
+      when /\A(async\s+)?(?:get\s+|set\s+)?(?:constructor|[A-Za-z_$][\w$]*)\s*\([^;]*\)\s*(?::\s*[^{}]+)?\s*(?:\{\}|\{|=>)?\z/
+        { kind: "method", signature: stripped } unless stripped.match?(/\A(if|for|while|switch|catch)\b/)
+      when /\A(export\s+)?(class|interface|type|enum)\s+(.+)/
+        { kind: Regexp.last_match(2), signature: stripped }
+      when /\A(?:export\s+)?(?:const|let|var)\s+\w+\s*=.*=>/
+        { kind: "function", signature: stripped }
+      when /\Afunc\s+(.+)/
+        { kind: "function", signature: stripped }
+      when /\Atype\s+\w+\s+(struct|interface)\b/
+        { kind: Regexp.last_match(1), signature: stripped }
+      when /\A(pub\s+)?(async\s+)?fn\s+(.+)/
+        { kind: "function", signature: stripped }
+      when /\A(pub\s+)?(struct|enum|trait|impl)\b(.+)?/
+        { kind: Regexp.last_match(2), signature: stripped }
+      when /\A(?:public|private|protected|internal|static|final|abstract|async|override|virtual|sealed|readonly|partial|\s)+\s*(class|interface|enum|record)\s+(.+)/
+        { kind: Regexp.last_match(1), signature: stripped }
+      when /\A(?:public|private|protected|internal|static|final|abstract|async|override|virtual|sealed|readonly|partial|\s)+\s*\S[^{;=]*\w+\s*\([^;]*\)\s*(?:\{|=>)?\z/
+        { kind: "method", signature: stripped }
+      end
+    end
+
+    def last_content_line(lines)
+      index = lines.rindex { |line| !line.strip.empty? }
+      index ? index + 1 : lines.length
+    end
+
+    def normalize_read_mode(mode)
+      return nil if mode.nil? || mode.to_s.empty?
+
+      value = mode.to_s.downcase
+      return value.to_sym if %w[preview outline range full].include?(value)
+
+      "Error: mode must be one of preview, outline, range, full"
+    end
+
+    def read_output_budget(max_bytes)
+      return @max_read_output_bytes if max_bytes.nil?
+
+      value = max_bytes.to_i
+      return "Error: max_bytes must be positive" unless value.positive?
+
+      [value, @max_read_output_bytes].min
+    end
+
+    def read_file_slice(content, offset:, limit:, max_bytes: @max_read_output_bytes)
       lines = content.split("\n", -1)
       lines = [""] if lines.empty?
       start_index = read_start_index(offset)
@@ -207,7 +348,7 @@ module Kward
 
       selected_end = user_limit ? [start_index + user_limit, lines.length].min : lines.length
       selected_lines = lines[start_index...selected_end]
-      truncated = truncate_read_lines(selected_lines)
+      truncated = truncate_read_lines(selected_lines, max_bytes: max_bytes)
       return truncated[:error] if truncated[:error]
 
       output = truncated[:content]
@@ -216,7 +357,8 @@ module Kward
           start_index: start_index,
           output_lines: truncated[:line_count],
           total_lines: lines.length,
-          truncated_by: truncated[:truncated_by]
+          truncated_by: truncated[:truncated_by],
+          max_bytes: max_bytes
         )
       elsif user_limit && selected_end < lines.length
         output << "\n\n[#{lines.length - selected_end} more lines in file. Use offset=#{selected_end + 1} to continue.]"
@@ -244,11 +386,11 @@ module Kward
       value
     end
 
-    def truncate_read_lines(lines)
+    def truncate_read_lines(lines, max_bytes: @max_read_output_bytes)
       first_line = lines.first.to_s
-      if first_line.bytesize > @max_read_output_bytes
+      if first_line.bytesize > max_bytes
         return {
-          error: "Error: first line is #{first_line.bytesize} bytes, exceeds #{@max_read_output_bytes} byte read limit. Use run_shell_command with sed/head to inspect smaller chunks."
+          error: "Error: first line is #{first_line.bytesize} bytes, exceeds #{max_bytes} byte read limit. Use run_shell_command with sed/head to inspect smaller chunks."
         }
       end
 
@@ -263,7 +405,7 @@ module Kward
 
         separator_bytes = output_lines.empty? ? 0 : 1
         next_bytes = line.bytesize + separator_bytes
-        if bytes + next_bytes > @max_read_output_bytes
+        if bytes + next_bytes > max_bytes
           truncated_by = "bytes"
           break
         end
@@ -280,10 +422,10 @@ module Kward
       }
     end
 
-    def read_truncation_notice(start_index:, output_lines:, total_lines:, truncated_by:)
+    def read_truncation_notice(start_index:, output_lines:, total_lines:, truncated_by:, max_bytes: @max_read_output_bytes)
       end_line = start_index + output_lines
       next_offset = end_line + 1
-      detail = truncated_by == "lines" ? "#{@max_read_output_lines} line limit" : "#{@max_read_output_bytes} byte limit"
+      detail = truncated_by == "lines" ? "#{@max_read_output_lines} line limit" : "#{max_bytes} byte limit"
       "\n\n[Showing lines #{start_index + 1}-#{end_line} of #{total_lines} (#{detail}). Use offset=#{next_offset} to continue.]"
     end