genie_cli 0.1.1

data/lib/tools/rename_file.rb

@@ -0,0 +1,45 @@
+require "fileutils"
+require "ruby_llm"
+
+module Genie
+  class RenameFile < RubyLLM::Tool
+    include SandboxedFileTool
+
+    description "Rename a file within the base path to a new location within the base path."
+    param :filepath, desc: "The path to the source file to rename."
+    param :new_path, desc: "The new path for the file."
+
+    def execute(filepath:, new_path:)
+      # Expand to absolute paths
+      src = File.expand_path(filepath)
+      dst = File.expand_path(new_path)
+
+      Genie.output "Renaming file from: #{src} to #{dst}", color: :blue
+
+      enforce_sandbox!(src)
+      enforce_sandbox!(dst)
+
+      # Check source exists
+      unless File.exist?(src)
+        raise "File not found. Cannot rename a non-existent file."
+      end
+
+      # Check destination does not exist
+      if File.exist?(dst)
+        raise "Destination already exists: #{dst}."
+      end
+
+      # Ensure destination directory exists
+      dest_dir = File.dirname(dst)
+      FileUtils.mkdir_p(dest_dir) unless Dir.exist?(dest_dir)
+
+      # Perform rename
+      FileUtils.mv(src, dst)
+
+      { success: true }
+    rescue => e
+      Genie.output "Error: #{e.message}", color: :red
+      { error: e.message }
+    end
+  end
+end

data/lib/tools/replace_lines_in_file.rb

@@ -0,0 +1,58 @@
+require "ruby_llm"
+
+module Genie
+  class ReplaceLinesInFile < RubyLLM::Tool
+    include SandboxedFileTool
+
+    description "Replace lines in a file between start and end indices (inclusive) with new content."
+    param :filepath, desc: "The path to the file to modify (must exist within base path)."
+    param :start_line, desc: "Zero-based starting line index to replace."
+    param :end_line, desc: "Zero-based ending line index to replace."
+    param :content, desc: "The new content to insert in place of the removed lines."
+
+    def execute(filepath:, start_line:, end_line:, content:)
+      start_line = start_line.to_i
+      end_line = end_line.to_i
+
+      # Expand to absolute path
+      filepath = File.expand_path(filepath)
+      Genie.output "Replacing lines in file: #{filepath}", color: :blue
+
+      enforce_sandbox!(filepath)
+
+      # Check file exists
+      unless File.exist?(filepath)
+        raise "File not found. Cannot replace lines in a non-existent file."
+      end
+
+      # Read lines
+      lines = File.readlines(filepath)
+      total = lines.size
+
+      # Validate indices
+      if !start_line.is_a?(Integer) || !end_line.is_a?(Integer) || start_line < 0 || end_line < start_line || end_line > total
+        raise "Invalid line numbers: start=#{start_line}, end=#{end_line}, file has #{total} lines."
+      end
+
+      # Split head and tail
+      head = lines[0...start_line]
+      tail = lines[(end_line + 1)..-1] || []
+
+      # Prepare new content lines
+      new_lines = content.to_s.each_line.to_a
+
+      # Combine
+      updated = head + new_lines + tail
+
+      # Write back
+      File.open(filepath, "w") do |f|
+        f.write(updated.join)
+      end
+
+      { success: true }
+    rescue => e
+      Genie.output "Error: #{e.message}", color: :red
+      { error: e.message }
+    end
+  end
+end

data/lib/tools/run_tests.rb

@@ -0,0 +1,38 @@
+module Genie
+  class RunTests < RubyLLM::Tool
+    description "Runs the test suite and returns the results"
+
+    def initialize(base_path:, cmd:)
+      @base_path = base_path
+      @base_path.freeze
+
+      @cmd = cmd || "rake test"
+      @cmd.freeze
+    end
+
+    # Stubbed execute method; to be implemented in a future iteration
+    def execute
+      Genie.output "Running tests...", color: :blue
+
+      # Run CMD within the base path
+      Dir.chdir(@base_path) do
+        begin
+          cmd = TTY::Command.new(printer: :quiet)
+          result = cmd.run!(@cmd)
+
+          if result.failure?
+            Genie.output "Tests failed!", color: :red
+            { result: "Tests failed", output: result.out, errors: result.err }
+          else
+            Genie.output "Tests passed successfully!", color: :green
+            { result: "Tests passed", output: result.out }
+          end
+        rescue => e
+          Genie.output "Error running tests: #{e.message}", color: :red
+          { error: e.message }
+        end
+      end
+
+    end
+  end
+end

data/lib/tools/take_a_note.rb

@@ -0,0 +1,14 @@
+module Genie
+  class TakeANote < RubyLLM::Tool
+    description "Take a note. The user will see this note. It can be useful to remember something, or explain to the user what you're thinking."
+    param :note, desc: "The text of the note you want stored."
+
+    def execute(note:)
+      Genie.output "Note: #{note}", color: :green
+
+      {
+        note: note,
+      }
+    end
+  end
+end

data/lib/tools/write_file.rb

@@ -0,0 +1,38 @@
+require "fileutils"
+
+module Genie
+  class WriteFile < RubyLLM::Tool
+    include SandboxedFileTool
+
+    description "Write a string to a file"
+    param :filepath, desc: "The path to the file to read (e.g., '/home/user/documents/file.txt')"
+    param :content, desc: "The content to write to the file"
+
+    def execute(filepath:, content:)
+      filepath = File.expand_path(filepath)
+
+      Genie.output "Writing file: #{filepath}", color: :blue
+
+      enforce_sandbox!(filepath)
+
+      indented_content = content.each_line.map { |line| "  #{line}" }.join
+
+      Genie.output "#{indented_content}", color: :green
+
+      # Ensure the directory exists
+      FileUtils.mkdir_p(File.dirname(filepath))
+
+      File.open(filepath, "w") do |file|
+        file.write(content)
+      end
+
+      {
+        success: true,
+      }
+    rescue => e
+      Genie.output "Error: #{e.message}", color: :red
+
+      { error: e.message }
+    end
+  end
+end

data/test/data/sample_config.yml

@@ -0,0 +1,5 @@
+---
+base_path: "/tmp/myapp/from_config"
+run_tests_cmd: "bundle exec tests_from_config_ex"
+model: "test_model_from_config"
+instructions: "Instructions from config file"

data/test/data/sample_files/read_file_test.txt

@@ -0,0 +1,3 @@
+Line1
+Line2
+Line3

data/test/test_cli.rb

@@ -0,0 +1,11 @@
+require_relative "test_helper"
+require 'yaml'
+
+class CliTest < TLDR
+
+  def test_runs_without_blowing_up
+    config = Genie::SessionConfig.default
+    Genie::Cli.new(config: config)
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,5 @@
+$LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
+
+require "genie"
+
+Genie.quiet! # Don't output the extra information

data/test/test_session.rb

@@ -0,0 +1,13 @@
+require_relative "test_helper"
+require 'tmpdir'
+
+class SessionTest < TLDR
+
+  def test_session_does_not_blow_up
+    config = Genie::SessionConfig.default
+    session = Genie::Session.new(config: config)
+
+    refute_equal nil, session
+  end
+
+end

data/test/test_session_config.rb

@@ -0,0 +1,55 @@
+require_relative "test_helper"
+require 'tmpdir'
+
+class SessionConfigTest < TLDR
+  def test_basic_session_config
+    config = Genie::SessionConfig.new(
+      base_path: "/my/cool/path",
+      run_tests_cmd: "bundle exec testit",
+      model: "gpt-4",
+      first_question: "What is the meaning of life?",
+      instructions: "Default instructions"
+    )
+
+    assert_equal "/my/cool/path", config.base_path
+    assert_equal "bundle exec testit", config.run_tests_cmd
+    assert_equal "gpt-4", config.model
+    assert_equal "What is the meaning of life?", config.first_question
+    assert config.instructions.include?("Default instructions")
+  end
+
+  def test_session_from_argv
+    argv = ["-c", "asdf.yml", "--base-path", "/tmp", "--run-tests", "rake test", "--model", "gpt-4o", "--instructions", "Command line instructions", "What is the meaning of life?"]
+    config = Genie::SessionConfig.from_argv(argv)
+
+    assert_equal "/tmp", config.base_path
+    assert_equal "rake test", config.run_tests_cmd
+    assert_equal "gpt-4o", config.model
+    assert_equal "What is the meaning of life?", config.first_question
+    assert config.instructions.include?("Command line instructions")
+  end
+
+  def test_session_from_config_file
+    argv = ["-c", "./test/data/sample_config.yml"]
+    config = Genie::SessionConfig.from_argv(argv)
+    expected_base_path = "/tmp/myapp/from_config"
+
+    assert_equal File.realpath(expected_base_path), File.realpath(config.base_path)
+    assert_equal "bundle exec tests_from_config_ex", config.run_tests_cmd
+    assert_equal "test_model_from_config", config.model
+    assert_equal nil, config.first_question
+    assert config.instructions.include?("Instructions from config file")
+  end
+
+  def test_default_instructions
+    config = Genie::SessionConfig.default
+    default_instructions = config.instructions
+    assert_includes default_instructions, "Genie coding assistant"
+    assert_includes default_instructions, "Test Driven Development"
+    assert_includes default_instructions, "tools available"
+    assert_includes default_instructions, "write tests first"
+    assert_includes default_instructions, "do not have access to any files outside"
+    assert_includes default_instructions, "do not have access to the internet"
+  end
+
+end

data/test/tools/test_append_to_file.rb

@@ -0,0 +1,29 @@
+require "tmpdir"
+
+require "tools/append_to_file"
+
+class TestAppendToFile < TLDR
+  def test_append_to_existing_file
+    Dir.mktmpdir do |dir|
+      file = "#{dir}/test_file.txt"
+      # Create initial content
+      File.write(file, "Hello\n")
+
+      result = Genie::AppendToFile.new(base_path: dir).execute(filepath: file, content: "World\n")
+      assert_equal true, result[:success]
+
+      actual = File.read(file)
+      expected = "Hello\nWorld\n"
+      assert_equal expected, actual
+    end
+  end
+
+  def test_error_for_file_outside_base_path
+    Dir.mktmpdir do |dir|
+      outside = "#{dir}/../outside.txt"
+
+      result = Genie::AppendToFile.new(base_path: dir).execute(filepath: outside, content: "data")
+      assert result[:error]&.include?("File not allowed"), "Expected error for file outside base path"
+    end
+  end
+end

data/test/tools/test_insert_into_file.rb

@@ -0,0 +1,97 @@
+require "tmpdir"
+
+class TestInsertIntoFile < TLDR
+  def test_insert_at_middle
+    Dir.mktmpdir do |dir|
+      file = "#{dir}/test.txt"
+      # Create initial content
+      File.write(file, "A\nB\nC\n")
+
+      result = Genie::InsertIntoFile.new(base_path: dir).execute(
+        filepath: file,
+        content: "X\n",
+        line_number: 2
+      )
+      assert_equal true, result[:success]
+
+      actual = File.read(file)
+      expected = "A\nX\nB\nC\n"
+      assert_equal expected, actual
+    end
+  end
+
+  def test_insert_at_beginning
+    Dir.mktmpdir do |dir|
+      file = "#{dir}/test.txt"
+      File.write(file, "Line1\nLine2\n")
+
+      result = Genie::InsertIntoFile.new(base_path: dir).execute(
+        filepath: file,
+        content: "New\n",
+        line_number: 1
+      )
+      assert_equal true, result[:success]
+      actual = File.read(file)
+      expected = "New\nLine1\nLine2\n"
+      assert_equal expected, actual
+    end
+  end
+
+  def test_insert_at_end
+    Dir.mktmpdir do |dir|
+      file = "#{dir}/test.txt"
+      File.write(file, "1\n2\n3\n")
+
+      # Append by specifying line_number one past last line
+      result = Genie::InsertIntoFile.new(base_path: dir).execute(
+        filepath: file,
+        content: "4\n",
+        line_number: 4
+      )
+      assert_equal true, result[:success]
+      actual = File.read(file)
+      expected = "1\n2\n3\n4\n"
+      assert_equal expected, actual
+    end
+  end
+
+  def test_error_for_invalid_line_number
+    Dir.mktmpdir do |dir|
+      file = "#{dir}/test.txt"
+      File.write(file, "Only one line\n")
+
+      result = Genie::InsertIntoFile.new(base_path: dir).execute(
+        filepath: file,
+        content: "Oops\n",
+        line_number: 0
+      )
+      assert result[:error]&.include?("Invalid line number"), "Expected error for invalid line number"
+    end
+  end
+
+  def test_error_for_file_outside_base_path
+    Dir.mktmpdir do |dir|
+      outside = "#{dir}/../outside.txt"
+
+      result = Genie::InsertIntoFile.new(base_path: dir).execute(
+        filepath: outside,
+        content: "data\n",
+        line_number: 1
+      )
+      assert result[:error]&.include?("File not allowed"), "Expected error for file outside base path"
+    end
+  end
+
+  def test_error_for_nonexistent_file
+    Dir.mktmpdir do |dir|
+      file = "#{dir}/no_file.txt"
+
+      result = Genie::InsertIntoFile.new(base_path: dir).execute(
+        filepath: file,
+        content: "data\n",
+        line_number: 1
+      )
+      assert result[:error]&.include?("File not found"), "Expected error for nonexistent file"
+    end
+  end
+end

data/test/tools/test_list_files.rb

@@ -0,0 +1,31 @@
+require "tools/list_files"
+
+class TestListFiles < TLDR
+  def test_list_files
+    actual = Genie::ListFiles.new(base_path: File.expand_path("../../", __dir__)).execute(directory: "./test/data/sample_files")
+
+    expected = [{ name: "read_file_test.txt", type: "file" },
+                { name: "one.txt", type: "file" },
+                { name: "a_dir", type: "directory" }]
+
+    assert_equal expected, actual
+  end
+
+  def test_list_files_in_invalid_directory
+    actual = Genie::ListFiles.new(base_path: "/tmp").execute(directory: "/blah/nothing/data/invalid_dir")
+
+    expected = { error: "Directory not allowed: /blah/nothing/data/invalid_dir. Must be within base path: /tmp" }
+
+    assert_equal expected, actual
+  end
+
+  def test_list_files_with_filter
+    base_path = File.expand_path("../../", __dir__)
+    t = Genie::ListFiles.new(base_path: base_path)
+    actual = t.execute(directory: "./test/data/sample_files", filter: "one")
+
+    expected = [{ name: "one.txt", type: "file" }]
+
+    assert_equal expected, actual
+  end
+end

data/test/tools/test_read_file.rb

@@ -0,0 +1,26 @@
+require "tools/read_file"
+require 'tmpdir'
+
+class TestReadFile < TLDR
+  def setup
+    @tmp_dir = Dir.mktmpdir
+    @file_path = File.join(@tmp_dir, "read_file_test.txt")
+    File.write(@file_path, "Line1\nLine2\nLine3\n")
+  end
+
+  def teardown
+    FileUtils.remove_entry(@tmp_dir)
+  end
+
+  def test_read_file_without_line_numbers
+    actual = Genie::ReadFile.new(base_path: @tmp_dir).execute(filepath: @file_path)
+    expected_contents = "Line1\nLine2\nLine3\n"
+    assert_equal({ contents: expected_contents }, actual)
+  end
+
+  def test_read_file_with_line_numbers
+    actual = Genie::ReadFile.new(base_path: @tmp_dir).execute(filepath: @file_path, include_line_numbers: true)
+    expected_contents = "1: Line1\n2: Line2\n3: Line3\n"
+    assert_equal({ contents: expected_contents }, actual)
+  end
+end

data/test/tools/test_rename_file.rb

@@ -0,0 +1,76 @@
+require "tmpdir"
+
+class TestRenameFile < TLDR
+  def test_rename_success
+    Dir.mktmpdir do |dir|
+      src = "#{dir}/old.txt"
+      dst = "#{dir}/new.txt"
+      content = "Hello"
+      File.write(src, content)
+
+      result = Genie::RenameFile.new(base_path: dir).execute(
+        filepath: src,
+        new_path: dst
+      )
+      assert_equal true, result[:success]
+
+      # Source should no longer exist, target should exist with content preserved
+      assert !File.exist?(src), "Expected source file to be removed"
+      assert File.exist?(dst), "Expected target file to exist"
+      assert_equal content, File.read(dst)
+    end
+  end
+
+  def test_error_for_source_outside_base_path
+    Dir.mktmpdir do |dir|
+      outside = "#{dir}/../outside.txt"
+      result = Genie::RenameFile.new(base_path: dir).execute(
+        filepath: outside,
+        new_path: "#{dir}/new.txt"
+      )
+      assert result[:error]&.include?("File not allowed"), "Expected error for source outside base path"
+    end
+  end
+
+  def test_error_for_destination_outside_base_path
+    Dir.mktmpdir do |dir|
+      src = "#{dir}/file.txt"
+      File.write(src, "data")
+      outside_dst = "/blah/new.txt"
+      result = Genie::RenameFile.new(base_path: dir).execute(
+        filepath: src,
+        new_path: outside_dst
+      )
+
+      assert result[:error]&.include?("File not allowed"), "Expected error for outside sandbox source file"
+
+    end
+  end
+
+  def test_error_for_nonexistent_source_file
+    Dir.mktmpdir do |dir|
+      src = "#{dir}/no_file.txt"
+      dst = "#{dir}/new.txt"
+      result = Genie::RenameFile.new(base_path: dir).execute(
+        filepath: src,
+        new_path: dst
+      )
+      assert result[:error]&.include?("File not found"), "Expected error for nonexistent source file"
+    end
+  end
+
+  def test_error_for_existing_destination_file
+    Dir.mktmpdir do |dir|
+      src = "#{dir}/a.txt"
+      dst = "#{dir}/b.txt"
+      File.write(src, "A")
+      File.write(dst, "B")
+
+      result = Genie::RenameFile.new(base_path: dir).execute(
+        filepath: src,
+        new_path: dst
+      )
+      assert result[:error]&.include?("Destination already exists"), "Expected error for existing destination file"
+    end
+  end
+end