ollama_chat 0.0.113 → 0.0.115

data/spec/ollama_chat/tools/move_file_spec.rb

@@ -49,6 +49,8 @@ describe OllamaChat::Tools::MoveFile do
     expect(File.exist?(source_path)).to be false
     expect(File.exist?(dest_path)).to be true
     expect(File.read(dest_path)).to eq content
+    expect(described_class.summary_template(result:))\
+      .to match(%r{File moved successfully from .*test_move_source.* to .*test_move_dest.*})
   ensure
     File.delete(source_path) if File.exist?(source_path)
     File.delete(dest_path) if File.exist?(dest_path)
@@ -80,6 +82,8 @@ describe OllamaChat::Tools::MoveFile do
     expect(json.success).to be_falsey
     expect(json.error).to eq 'OllamaChat::InvalidPathError'
     expect(json.message).to include('does already exist')
+    expect(described_class.summary_template(result:))\
+      .to include('does already exist')
 
     # Verify files are still there (no move happened)
     expect(File.exist?(source_path)).to be true
@@ -112,6 +116,8 @@ describe OllamaChat::Tools::MoveFile do
     expect(json.success).to be_falsey
     expect(json.error).to eq 'OllamaChat::InvalidPathError'
     expect(json.message).to include('does not exist')
+    expect(described_class.summary_template(result:))\
+      .to include('does not exist')
   ensure
     File.delete(dest_path) if File.exist?(dest_path)
   end
@@ -134,6 +140,8 @@ describe OllamaChat::Tools::MoveFile do
     json = json_object(result)
     expect(json.error).to eq 'OllamaChat::InvalidPathError'
     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 'handles general exceptions gracefully' do
@@ -161,6 +169,8 @@ describe OllamaChat::Tools::MoveFile do
     json = json_object(result)
     expect(json.error).to eq 'RuntimeError'
     expect(json.message).to include('Unexpected system error')
+    expect(described_class.summary_template(result:))\
+      .to include('Unexpected system error')
   ensure
     File.delete(source_path) if File.exist?(source_path)
     File.delete(dest_path) if File.exist?(dest_path)

data/spec/ollama_chat/tools/open_file_in_editor_spec.rb

@@ -32,6 +32,8 @@ describe OllamaChat::Tools::OpenFileInEditor do
     expect(json.path).to eq asset('example.rb')
     expect(json.start_line).to eq 42
     expect(json.message).to match(%r(spec/assets/example.rb" at line 42))
+    expect(described_class.summary_template(result:)).
+      to match(%r(spec/assets/example.rb" at line 42))
   end
 
   it 'can be executed successfully with valid path, start_line, end_line' do
@@ -54,6 +56,8 @@ describe OllamaChat::Tools::OpenFileInEditor do
     expect(json.start_line).to eq 23
     expect(json.end_line).to eq 42
     expect(json.message).to match(%r(spec/assets/example.rb" and selected range 23-42))
+    expect(described_class.summary_template(result:)).
+      to match(%r(spec/assets/example.rb" and selected range 23-42))
   end
 
   it 'can handle invalid path gracefully' do
@@ -74,6 +78,8 @@ describe OllamaChat::Tools::OpenFileInEditor do
 
     expect(json.error).to eq 'Errno::ENOENT'
     expect(json.message).to include('No such file or directory')
+    expect(described_class.summary_template(result:)).
+      to include('No such file or directory')
   end
 
   it 'can be converted to hash' do

data/spec/ollama_chat/tools/paste_from_clipboard_spec.rb

@@ -40,6 +40,7 @@ describe OllamaChat::Tools::PasteFromClipboard do
     expect(json.error).to be_nil # No exception was raised
     expect(json.success).to be true
     expect(json.message).to eq "Pasted 11.0 B of content."
+    expect(described_class.summary_template(result:)).to eq "Pasted 11.0 B of content."
   end
 
   it 'can be executed with edit option' do
@@ -65,6 +66,7 @@ describe OllamaChat::Tools::PasteFromClipboard do
     expect(json.error).to be_nil
     expect(json.success).to be true
     expect(json.message).to eq "Pasted 18.0 B of content."
+    expect(described_class.summary_template(result:)).to eq "Pasted 18.0 B of content."
   end
 
   it 'can handle execution errors gracefully' do
@@ -89,6 +91,8 @@ describe OllamaChat::Tools::PasteFromClipboard do
     json = json_object(result)
     expect(json.error).to eq 'OllamaChat::OllamaChatError'
     expect(json.message).to eq 'No content available to paste from the system clipboard.'
+    expect(described_class.summary_template(result:)).to eq \
+      'No content available to paste from the system clipboard.'
   end
 
   it 'can handle execution exceptions gracefully' do
@@ -113,5 +117,6 @@ describe OllamaChat::Tools::PasteFromClipboard do
     json = json_object(result)
     expect(json.error).to eq 'RuntimeError'
     expect(json.message).to eq 'some kind of exception'
+    expect(described_class.summary_template(result:)).to eq 'some kind of exception'
   end
 end

data/spec/ollama_chat/tools/paste_into_editor_spec.rb

@@ -41,6 +41,8 @@ describe OllamaChat::Tools::PasteIntoEditor do
       expect(json.message).to eq(
         'The provided text has been successfully pasted into the editor.'
       )
+      expect(described_class.summary_template(result:)).to eq \
+        'The provided text has been successfully pasted into the editor.'
     end
   end
 
@@ -64,6 +66,8 @@ describe OllamaChat::Tools::PasteIntoEditor do
 
       expect(json.error).to eq('OllamaChat::OllamaChatError')
       expect(json.message).to eq('Insert failed')
+      expect(described_class.summary_template(result:)).to eq \
+        'Insert failed'
     end
 
     it 'captures generic RuntimeError and returns JSON with the error details' do
@@ -75,6 +79,8 @@ describe OllamaChat::Tools::PasteIntoEditor do
 
       expect(json.error).to eq('RuntimeError')
       expect(json.message).to eq('Some exception')
+      expect(described_class.summary_template(result:)).to eq \
+        'Some exception'
     end
   end
 

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',
@@ -39,10 +40,12 @@ describe OllamaChat::Tools::ReadFile do
     expect(json.content).to eq <<~EOT
       puts "Hello World!"
     EOT
-    expect(json.message).to include('Read 20.0 B (6.0 T) from')
+    expect(json.message).to include('Read 6.0 T (20.0 B) from')
     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 6.0 T (20.0 B) from')
   end
 
   it 'can extract range when start_line is provided and end_line is nil' do
@@ -61,7 +64,7 @@ describe OllamaChat::Tools::ReadFile do
     result = described_class.new.execute(tool_call, chat:)
     json = json_object(result)
     expect(json.content).to eq "puts \"Hello World!\"\n"
-    expect(json.message).to include('Read 20.0 B (6.0 T) from')
+    expect(json.message).to include('Read 6.0 T (20.0 B) from')
     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
@@ -83,7 +86,7 @@ describe OllamaChat::Tools::ReadFile do
     result = described_class.new.execute(tool_call, chat:)
     json = json_object(result)
     expect(json.content).to eq "puts \"Hello World!\"\n"
-    expect(json.message).to include('Read 20.0 B (6.0 T) from')
+    expect(json.message).to include('Read 6.0 T (20.0 B) from')
     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
@@ -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

@@ -41,7 +41,9 @@ describe OllamaChat::Tools::WriteFile do
     json = json_object(result)
     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(json.message).to include('Wrote 4.0 T (13.0 B) to file')
+    expect(described_class.summary_template(result:)).
+      to include('Wrote 4.0 T (13.0 B) 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 4.0 T (11.0 B) 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)
@@ -130,7 +136,9 @@ describe OllamaChat::Tools::WriteFile do
     json = json_object(result)
     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(json.message).to include('Wrote 6.0 T (18.0 B) to file')
+    expect(described_class.summary_template(result:)).
+      to include('Wrote 6.0 T (18.0 B) 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 5.0 T (15.0 B) 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