ollama_chat 0.0.113 → 0.0.114

data/spec/ollama_chat/tools/patch_file_spec.rb

@@ -142,6 +142,8 @@ describe OllamaChat::Tools::PatchFile do
 
     result = tool.execute(tool_call, chat:)
     expect(json_object(result).success).to eq true
+    expect(described_class.summary_template(result:))\
+      .to match(/Successfully applied patch to/)
   ensure
     File.delete(test_file) if File.exist?(test_file)
   end
@@ -152,6 +154,8 @@ describe OllamaChat::Tools::PatchFile do
 
     result = tool.execute(tool_call, chat:)
     expect(json_object(result).error).to eq 'OllamaChat::ToolFunctionArgumentError'
+    expect(described_class.summary_template(result:))\
+      .to match(/Failed to apply patch to file/)
   end
 
   it 'can handle execution errors gracefully when path is not expected' do
@@ -188,4 +192,62 @@ describe OllamaChat::Tools::PatchFile do
   ensure
     File.delete(test_file) if File.exist?(test_file)
   end
+
+  describe 'syntax check integration' do
+    let :test_rb_file do
+      "./tmp/patch_syntax_#{Tins::Token.new(bits: 128)}.rb"
+    end
+
+    after do
+      File.delete(test_rb_file) if File.exist?(test_rb_file)
+    end
+
+    it 'includes syntax_check fail on broken .rb patch' do
+      const_conf_as('OC::DIFF_TOOL' => Pathname.new(`which true`.chomp))
+      File.write(test_rb_file, "def foo\n  42\nend\n")
+      content = File.read(test_rb_file)
+
+      edits = [{ start_line: 2, end_line: 2, text: 'end' }]
+      checksum = '%08x' % Zlib.crc32(content)
+      args_double = double('Arguments', path: test_rb_file, edits:, checksum:)
+      tool_call = double('ToolCall', function: double(name: 'patch_file', arguments: args_double))
+
+      tmp_double = double('Tempfile', write: true, flush: true, path: '/tmp/test_patch')
+      expect(chat).to receive(:edit_text_block).and_yield(tmp_double)
+      expect(tool).to receive(:system).and_return(true)
+      expect(tool).to receive(:digest).and_return 'old', 'new'
+
+      checker = double('checker', cmd: ['ruby', '-wc'])
+      expect(chat).to receive(:syntax_checker_for).and_return(checker)
+      expect(chat).to receive(:run_syntax_check).with(checker, any_args)
+        .and_return({ status: 'fail',
+                      output: "test.rb:2: syntax error" })
+
+      result = tool.execute(tool_call, chat:)
+      json = json_object(result)
+      expect(json.message).to include('❌ Syntax error detected')
+      expect(json.syntax_check[:status]).to eq 'fail'
+    end
+
+    it 'omits syntax_check when no checker matches' do
+      const_conf_as('OC::DIFF_TOOL' => Pathname.new(`which true`.chomp))
+      File.write(test_file, "Line 1\nLine 2\n")
+      content = File.read(test_file)
+
+      edits = [{ start_line: 2, end_line: 2, text: 'Modified' }]
+      checksum = '%08x' % Zlib.crc32(content)
+      args_double = double('Arguments', path: test_file, edits:, checksum:)
+      tool_call = double('ToolCall', function: double(name: 'patch_file', arguments: args_double))
+
+      tmp_double = double('Tempfile', write: true, flush: true, path: '/tmp/test_patch')
+      expect(chat).to receive(:edit_text_block).and_yield(tmp_double)
+      expect(tool).to receive(:system).and_return(true)
+      expect(tool).to receive(:digest).and_return 'old', 'new'
+      expect(chat).to receive(:syntax_checker_for).and_return(nil)
+
+      result = tool.execute(tool_call, chat:)
+      json = json_object(result)
+      expect(json.syntax_check).to be_nil
+    end
+  end
 end

data/spec/ollama_chat/tools/read_file_spec.rb

@@ -17,6 +17,7 @@ describe OllamaChat::Tools::ReadFile do
     expect(described_class.new.to_hash).to be_a Hash
   end
 
+
   it 'can be executed successfully' do
     tool_call = double(
       'ToolCall',
@@ -43,6 +44,8 @@ describe OllamaChat::Tools::ReadFile do
     expect(json.mtime).to match(/\A\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/)
     expect(json.line_count).to be_nil
     expect(json.checksum).not_to be_present
+    expect(described_class.summary_template(result:))\
+      .to include('Read 20.0 B (6.0 T) from')
   end
 
   it 'can extract range when start_line is provided and end_line is nil' do
@@ -198,6 +201,8 @@ describe OllamaChat::Tools::ReadFile do
     expect(json.path).to eq '/etc/passwd'
     expect(json.message).to include('is not within allowed directories')
     expect(json.checksum).not_to be_present
+    expect(described_class.summary_template(result:))\
+      .to include('is not within allowed directories')
   end
 
   it 'can handle exceptions gracefully' do
@@ -222,5 +227,7 @@ describe OllamaChat::Tools::ReadFile do
     expect(json.error).to eq 'OllamaChat::InvalidPathError'
     expect(json.checksum).to be_nil
     expect(json.message).to match(/Failed to read file:.* does not exist/)
+    expect(described_class.summary_template(result:))\
+      .to match(/Failed to read file:.* does not exist/)
   end
 end

data/spec/ollama_chat/tools/resolve_tag_spec.rb

@@ -60,6 +60,8 @@ describe OllamaChat::Tools::ResolveTag do
       expect(json.results).to be_present
       expect(json.symbol).to  eq 'execute'
       expect(json.kind).to    eq ?f
+      expect(described_class.summary_template(result:)).to eq \
+        'Found 2 results of symbol "execute".'
     end
   end
 
@@ -85,6 +87,50 @@ describe OllamaChat::Tools::ResolveTag do
       json = json_object(result)
       expect(json.error).to eq('RuntimeError')
       expect(json.message).to include('some error')
+      expect(described_class.summary_template(result:)).to include('some error')
+    end
+  end
+
+  context 'when a tag line triggers the internal rescue path' do
+    let(:tags_path) { File.join(Dir.pwd, 'tmp', 'test_tags.ctags') }
+
+    before do
+      FileUtils.mkdir_p(File.dirname(tags_path))
+      # Valid ctags format: symbol\tfilename\t/^regexp$/;"\tkind rest
+      # 5 regex captures, but TagResult needs 6 (…+ :linenumber),
+      # so TagResult.new always raises ArgumentError → rescue fires.
+      File.write(tags_path, \
+        "execute\tlib/foo.rb\t/^  def execute\\($/;\"\tf method\n")
+      const_conf_as(
+        'OC::OLLAMA::CHAT::TOOLS::CTAGS_TOOL' => 'true',
+        'OC::OLLAMA::CHAT::TOOLS::TAGS_FILE'  => Pathname.new(tags_path),
+      )
+    end
+
+    after do
+      File.delete(tags_path) if File.exist?(tags_path)
+    end
+
+    it 'logs via chat.log and returns empty results' do
+      tool_call = double(
+        'ToolCall',
+        function: double(
+          name: 'resolve_tag',
+          arguments: double(symbol: 'execute', kind: nil, directory: nil)
+        )
+      )
+
+      expect(chat).to receive(:log).
+        with(:error, kind_of(ArgumentError),
+           hash_including(data: { context: 'tag_resolver' })).
+        and_return(nil)
+
+      result = described_class.new.execute(tool_call, chat:)
+      json = json_object(result)
+
+      expect(json.error).to be_nil
+      expect(json.results).to eq []
+      expect(json.message).to eq 'Found 0 results of symbol "execute".'
     end
   end
 end

data/spec/ollama_chat/tools/roll_dice_spec.rb

@@ -44,6 +44,8 @@ describe OllamaChat::Tools::RollDice do
     expect(json.modifier).to eq 0
     expect(json.total).to eq 7
     expect(json.message).to eq 'Dice roll was: 2d6 = 2…12 = (2 + 5) = 7'
+    expect(described_class.summary_template(result:)).to eq \
+      'Dice roll was: 2d6 = 2…12 = (2 + 5) = 7'
   end
 
   it 'can be executed successfully with d20 notation' do
@@ -65,6 +67,8 @@ describe OllamaChat::Tools::RollDice do
     expect(json.rolls).to eq [10]
     expect(json.total).to eq 10
     expect(json.message).to eq 'Dice roll was: d20 = 1…20 = (10) = 10'
+    expect(described_class.summary_template(result:)).to eq \
+      'Dice roll was: d20 = 1…20 = (10) = 10'
   end
 
   it 'can be executed successfully with positive modifier' do
@@ -87,6 +91,8 @@ describe OllamaChat::Tools::RollDice do
     expect(json.modifier).to eq 3
     expect(json.total).to eq 18
     expect(json.message).to eq 'Dice roll was: d20+3 = 4…23 = (15) + 3 = 18'
+    expect(described_class.summary_template(result:)).to eq \
+      'Dice roll was: d20+3 = 4…23 = (15) + 3 = 18'
   end
 
   it 'can be executed successfully with negative modifier' do
@@ -109,6 +115,8 @@ describe OllamaChat::Tools::RollDice do
     expect(json.modifier).to eq(-3)
     expect(json.total).to eq 2
     expect(json.message).to eq 'Dice roll was: d20-3 = -2…17 = (5) - 3 = 2'
+    expect(described_class.summary_template(result:)).to eq \
+      'Dice roll was: d20-3 = -2…17 = (5) - 3 = 2'
   end
 
   it 'can handle invalid dice notation' do
@@ -126,6 +134,9 @@ describe OllamaChat::Tools::RollDice do
     json = json_object(result)
     expect(json.error).to eq 'OllamaChat::ToolFunctionArgumentError'
     expect(json.message).to match(/Invalid dice notation/)
+    expect(described_class.summary_template(result:)).to match(
+      /Invalid dice notation/
+    )
   end
 
   it 'can be converted to hash' do

data/spec/ollama_chat/tools/run_tests_spec.rb

@@ -60,6 +60,9 @@ describe OllamaChat::Tools::RunTests do
     expect(json.success).to be true
     expect(json.path).to eq 'spec/ollama_chat/tools/my_spec.rb'
     expect(json.status).to eq 'passed'
+    expect(described_class.summary_template(result:)).to eq \
+      '✨ All tests passed successfully in ' \
+      '"spec/ollama_chat/tools/my_spec.rb"!'
   end
 
   it 'can be executed successfully with a path and coverage' do
@@ -108,6 +111,10 @@ describe OllamaChat::Tools::RunTests do
     json = json_object(result)
     expect(json.success).to be false
     expect(json.status).to eq 'failed'
+    expect(described_class.summary_template(result:)).to eq \
+      '❌ Some tests failed in ' \
+      '"spec/ollama_chat/tools/my_spec.rb". ' \
+      'Please check the error messages above.'
   end
 
   it 'can handle unexpected errors gracefully' do
@@ -129,6 +136,7 @@ describe OllamaChat::Tools::RunTests do
     json = json_object(result)
     expect(json.error).to eq 'StandardError'
     expect(json.message).to eq 'Unexpected boom'
+    expect(described_class.summary_template(result:)).to eq 'Unexpected boom'
   end
 
   context 'path auto-discovery' do

data/spec/ollama_chat/tools/search_knowledge_spec.rb

@@ -120,6 +120,8 @@ describe OllamaChat::Tools::SearchKnowledge do
 
     mock_docs = double('Documents')
     expect(chat).to receive(:documents).and_return(mock_docs).at_least(:once)
+    expect(chat).to receive(:database_collection?).with('tolkien').
+      and_return(double('Col', enabled: true))
 
     expect(mock_docs).to receive(:collection).and_return('default_collection').
       at_least(:once)

data/spec/ollama_chat/tools/write_file_spec.rb

@@ -42,6 +42,8 @@ describe OllamaChat::Tools::WriteFile do
     expect(json.success).to eq true
     expect(json.path).to include(File.basename(test_write_file))
     expect(json.message).to include('Wrote 13.0 B (4.0 T) to file')
+    expect(described_class.summary_template(result:)).
+      to include('Wrote 13.0 B (4.0 T) to file')
 
     # Verify file was actually written
     expect(File.exist?(test_write_file)).to be true
@@ -74,6 +76,8 @@ describe OllamaChat::Tools::WriteFile do
     json = json_object(result)
     expect(json.success).to eq true
     expect(File.read(test_write_file)).to eq 'New content'
+    expect(described_class.summary_template(result:)).
+      to include('Wrote 11.0 B (4.0 T) to file')
   ensure
     File.delete(test_write_file) if File.exist?(test_write_file)
   end
@@ -101,6 +105,8 @@ describe OllamaChat::Tools::WriteFile do
     json = json_object(result)
     expect(json.error).to eq 'OllamaChat::ToolFunctionArgumentError'
     expect(json.message).to include('Write rejected')
+    expect(described_class.summary_template(result:)).
+      to include('Write rejected')
     expect(File.read(test_write_file)).to eq 'Old content'
   ensure
     File.delete(test_write_file) if File.exist?(test_write_file)
@@ -131,6 +137,8 @@ describe OllamaChat::Tools::WriteFile do
     expect(json.success).to be true
     expect(json.path).to include(File.basename(test_write_file))
     expect(json.message).to include('Wrote 18.0 B (6.0 T) to file')
+    expect(described_class.summary_template(result:)).
+      to include('Wrote 18.0 B (6.0 T) to file')
 
     # Verify file was actually appended
     expect(File.exist?(test_write_file)).to be true
@@ -162,6 +170,8 @@ describe OllamaChat::Tools::WriteFile do
     json = json_object(result)
     expect(json.success).to eq true
     expect(File.read(test_write_file)).to eq 'First content\n'
+    expect(described_class.summary_template(result:)).
+      to include('Wrote 15.0 B (5.0 T) to file')
   ensure
     File.delete(test_write_file) if File.exist?(test_write_file)
   end
@@ -186,6 +196,8 @@ describe OllamaChat::Tools::WriteFile do
     json = json_object(result)
     expect(json.error).to eq 'OllamaChat::ToolFunctionArgumentError'
     expect(json.message).to include('Write rejected')
+    expect(described_class.summary_template(result:)).
+      to include('Write rejected')
     expect(File.exist?(test_write_file)).to be false
   end
 
@@ -210,6 +222,8 @@ describe OllamaChat::Tools::WriteFile do
     expect(json.error).to eq 'OllamaChat::InvalidPathError'
     expect(json.path).to eq '/etc/passwd'
     expect(json.message).to include('is not within allowed directories')
+    expect(described_class.summary_template(result:)).
+      to include('is not within allowed directories')
   end
 
   it 'can handle execution errors gracefully when mode is invalid' do
@@ -232,6 +246,8 @@ describe OllamaChat::Tools::WriteFile do
     json = json_object(result)
     expect(json.error).to eq 'ArgumentError'
     expect(json.message).to include('Invalid mode')
+    expect(described_class.summary_template(result:)).
+      to include('Invalid mode')
   end
 
   it 'can handle exceptions gracefully' do
@@ -256,5 +272,85 @@ describe OllamaChat::Tools::WriteFile do
     expect(json.error).to eq 'RuntimeError'
     expect(json.path).to be_nil
     expect(json.message).to eq 'Failed to write to file: some error'
+    expect(described_class.summary_template(result:)).to eq \
+      'Failed to write to file: some error'
+  end
+
+  describe 'syntax check integration' do
+    let :test_rb_file do
+      "./tmp/test_syntax_#{Tins::Token.new(bits: 128)}.rb"
+    end
+
+    after do
+      File.delete(test_rb_file) if File.exist?(test_rb_file)
+    end
+
+    it 'includes syntax_check on valid .rb file (omits clean pass)' do
+      expect(chat).to receive(:syntax_checker_for).and_return(nil)
+
+      tool_call = double(
+        'ToolCall',
+        function: double(
+          name: 'write_file',
+          arguments: double(
+            path: test_rb_file,
+            content: "def foo\n  42\nend\n",
+            mode: 'overwrite'
+          )
+        )
+      )
+
+      result = described_class.new.execute(tool_call, chat:)
+      json = json_object(result)
+      expect(json.success).to eq true
+      expect(json.syntax_check).to be_nil
+    end
+
+    it 'includes syntax_check fail on broken .rb file' do
+      checker = double('checker', cmd: ['ruby', '-wc'])
+      expect(chat).to receive(:syntax_checker_for).and_return(checker)
+      expect(chat).to receive(:run_syntax_check).with(checker, any_args)
+        .and_return({ status: 'fail',
+                      output: "test.rb:2: syntax error, unexpected 'end'" })
+
+      tool_call = double(
+        'ToolCall',
+        function: double(
+          name: 'write_file',
+          arguments: double(
+            path: test_rb_file,
+            content: "def foo\nend\nend\n",
+            mode: 'overwrite'
+          )
+        )
+      )
+
+      result = described_class.new.execute(tool_call, chat:)
+      json = json_object(result)
+      expect(json.success).to eq true
+      expect(json.message).to include('❌ Syntax error detected')
+      expect(json.syntax_check[:status]).to eq 'fail'
+    end
+
+    it 'omits syntax_check for non-matching extension' do
+      expect(chat).to receive(:syntax_checker_for).and_return(nil)
+
+      tool_call = double(
+        'ToolCall',
+        function: double(
+          name: 'write_file',
+          arguments: double(
+            path: test_write_file,
+            content: 'plain text',
+            mode: 'overwrite'
+          )
+        )
+      )
+
+      result = described_class.new.execute(tool_call, chat:)
+      json = json_object(result)
+      expect(json.success).to eq true
+      expect(json.syntax_check).to be_nil
+    end
   end
 end

data/spec/ollama_chat/utils/analyze_directory_spec.rb

@@ -35,16 +35,11 @@ describe OllamaChat::Utils::AnalyzeDirectory do
       expect(sub[:children].map { |e| e[:depth] }).to eq [ 1 ]
     end
 
-    it 'returns an array of entries with depth max_depth' do
-      result = generate.call(@tmp_dir, max_depth: 0)
+    it 'max_depth 1 prunes all children from directories' do
+      result = generate.call(@tmp_dir, max_depth: 1)
 
-      expect(result).to be_an(Array)
       expect(result.map { |e| e[:name] }).to contain_exactly('a.txt', 'b.rb', 'sub')
-
       sub = result.find { |e| e[:name] == 'sub' }
-      expect(sub[:depth]).to eq 0
-      expect(sub[:type]).to eq('directory')
-      expect(sub[:children]).to be_an(Array)
       expect(sub[:children]).to be_empty
     end
 
@@ -55,6 +50,50 @@ describe OllamaChat::Utils::AnalyzeDirectory do
       expect(names).to include('example.rb')
       expect(names).not_to include('examplle.json', 'example.md')
     end
+
+    context 'max_depth with nested directories' do
+      before do
+        @tmp_dir  = Dir.mktmpdir
+        @sub_dir  = File.join(@tmp_dir, 'sub')
+        @deep_dir = File.join(@sub_dir, 'deep')
+        Dir.mkdir(@sub_dir)
+        Dir.mkdir(@deep_dir)
+        @file_a   = File.join(@tmp_dir, 'a.txt')
+        @file_b   = File.join(@sub_dir, 'b.txt')
+        @file_c   = File.join(@deep_dir, 'c.txt')
+
+        File.write(@file_a, 'a')
+        File.write(@file_b, 'b')
+        File.write(@file_c, 'c')
+      end
+
+      it 'max_depth 1 shows only immediate children' do
+        result = generate.call(@tmp_dir, max_depth: 1)
+
+        expect(result.map { |e| e[:name] }).to contain_exactly('a.txt', 'sub')
+        sub = result.find { |e| e[:name] == 'sub' }
+        expect(sub[:children]).to be_empty
+      end
+
+      it 'max_depth 2 shows children and grandchildren' do
+        result = generate.call(@tmp_dir, max_depth: 2)
+
+        expect(result.map { |e| e[:name] }).to contain_exactly('a.txt', 'sub')
+        sub  = result.find { |e| e[:name] == 'sub' }
+        deep = sub[:children].find { |e| e[:name] == 'deep' }
+
+        expect(sub[:children].map { |e| e[:name] })
+          .to contain_exactly('b.txt', 'deep')
+        expect(deep[:children]).to be_empty
+      end
+
+      it 'max_depth exceeding height returns the full tree' do
+        full   = generate.call(@tmp_dir)
+        pruned = generate.call(@tmp_dir, max_depth: 99)
+
+        expect(pruned.to_json).to eq full.to_json
+      end
+    end
   end
 
   context 'skipping hidden files and symlinks' do

data/spec/ollama_chat/utils/log_rotation_spec.rb

@@ -0,0 +1,71 @@
+require 'tmpdir'
+
+describe OllamaChat::Utils::LogRotation do
+  describe '.truncate_tail' do
+    it 'is a no-op when the file does not exist' do
+      described_class.truncate_tail('/nonexistent/test.log', keep_lines: 10)
+    end
+
+    it 'is a no-op for an empty file' do
+      Dir.mktmpdir do |dir|
+        log = File.join(dir, 'test.log')
+        File.write(log, '')
+        described_class.truncate_tail(log, keep_lines: 10)
+        expect(File.read(log)).to eq ''
+      end
+    end
+
+    it 'is a no-op when the file has fewer lines than keep_lines' do
+      Dir.mktmpdir do |dir|
+        log = File.join(dir, 'test.log')
+        File.write(log, "line1\nline2\nline3\n")
+        described_class.truncate_tail(log, keep_lines: 10)
+        expect(File.read(log)).to eq "line1\nline2\nline3\n"
+      end
+    end
+
+    it 'is a no-op when the file has exactly keep_lines lines' do
+      Dir.mktmpdir do |dir|
+        log = File.join(dir, 'test.log')
+        File.write(log, (1..10).map { |i| "line #{i}\n" }.join)
+        described_class.truncate_tail(log, keep_lines: 10)
+        expect(File.read(log).lines.length).to eq 10
+      end
+    end
+
+    it 'truncates to the last keep_lines lines' do
+      Dir.mktmpdir do |dir|
+        log = File.join(dir, 'test.log')
+        File.write(log, (1..100).map { |i| "line #{i}\n" }.join)
+        described_class.truncate_tail(log, keep_lines: 10)
+        content = File.read(log)
+        lines = content.lines
+        expect(lines.length).to eq 10
+        expect(lines.first).to eq "line 91\n"
+        expect(lines.last).to eq "line 100\n"
+      end
+    end
+
+    it 'preserves the inode' do
+      Dir.mktmpdir do |dir|
+        log = File.join(dir, 'test.log')
+        File.write(log, (1..100).map { |i| "line #{i}\n" }.join)
+        before_ino = File.stat(log).ino
+        described_class.truncate_tail(log, keep_lines: 10)
+        expect(File.stat(log).ino).to eq before_ino
+      end
+    end
+
+    it 'handles a file without a trailing newline' do
+      Dir.mktmpdir do |dir|
+        log = File.join(dir, 'test.log')
+        File.write(log, (1..50).map { |i| "line #{i}\n" }.join)
+        File.open(log, 'a') { |f| f.puts('final') }
+        described_class.truncate_tail(log, keep_lines: 10)
+        lines = File.read(log).lines
+        expect(lines.length).to eq 10
+        expect(lines.last).to eq "final\n"
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -218,7 +218,8 @@ RSpec.configure do |config|
     OllamaChat.test_mode = true
     const_conf_as(
       'OC::OLLAMA::CHAT::HISTORY'          => Pathname.pwd.join('tmp', 'history.json'),
-      'OC::OLLAMA::CHAT::LOGFILE'          => Pathname.pwd.join('tmp', 'chat.log'),
+      'OC::OLLAMA::CHAT::LOG::CHAT'        => Pathname.pwd.join('tmp', 'chat.log'),
+      'OC::OLLAMA::CHAT::LOG::DATABASE'    => Pathname.pwd.join('tmp', 'database.log'),
     )
   end