n2b 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c3de539be7363cf775fc09b14001ae6775670075543030ba46d1b8c176e3ec7e
+  data.tar.gz: c01a0bca5a0df44a9736c78c574d9f9c0ba056012d188c6b8a1386bcad48d6cb
+SHA512:
+  metadata.gz: 2c815152121062403a7f5985c3cad091caaaa04f5774f467debae307747072fb293343e7d25fa008aed916e1b2c40c3ef08436af25f21a6b6a9dc0e6d7fe9aae
+  data.tar.gz: a144fd904d8c7b37d28eb56e2f6977275fa4107a70da126ea936e727271149bc9146e6ce1103b2dab3cc03ee896186027e220c332d02f1508435f96d8d1530f1

data/README.md

@@ -0,0 +1,90 @@
+# N2B: Natural Language to Bash Commands Converter
+
+N2B (Natural to Bash) is a Ruby gem that converts natural language instructions into executable shell commands using the Claude AI API. It's designed to help users quickly generate shell commands without needing to remember exact syntax.
+
+## Features
+
+- Convert natural language to shell commands
+- Support for multiple Claude AI models (Haiku, Sonnet, Sonnet 3.5)
+- Option to execute generated commands directly
+- Configurable privacy settings
+- Shell history integration
+- Command history tracking for improved context
+
+## Installation
+
+Install the gem by running:
+gem install n2b
+
+## Configuration
+
+Before using n2b, you need to configure it with your Claude API key and preferences. Run:
+n2b -c
+
+This will prompt you to enter:
+- Your Claude API key
+- Preferred Claude model (haiku, sonnet, or sonnet35)
+- Privacy settings (whether to send shell history, past requests, current directory)
+- Whether to append generated commands to your shell history
+
+Configuration is stored in `~/.n2b/config.yml`.
+
+## Usage
+
+Basic usage:
+
+n2b [options] your natural language instruction
+
+Options:
+- `-x` or `--execute`: Execute the generated commands after confirmation
+- `-c` or `--config`: Reconfigure the tool
+- `-h` or `--help`: Display help information
+
+Examples:
+
+1. Generate commands without executing:
+
+n2b list all PDF files in the current directory
+
+2. Generate and execute commands:
+
+n2b -x create a new directory named 'project' and initialize a git repository in it
+
+3. Reconfigure the tool:
+
+n2b -c 
+
+## How It Works
+
+1. N2B takes your natural language input and sends it to the Claude AI API.
+2. The AI generates appropriate shell commands based on your input and configured shell.
+3. N2B displays the generated commands and explanations (if any).
+4. If the execute option is used, N2B will prompt for confirmation before running the commands.
+5. Optionally, commands are added to your shell history for future reference.
+
+## Privacy
+
+N2B allows you to configure what information is sent to the Claude API:
+- Shell history
+- Past n2b requests and responses
+- Current working directory
+
+You can adjust these settings during configuration.
+
+## Limitations
+
+- The quality of generated commands depends on the Claude AI model's capabilities.
+- Complex or ambiguous instructions might not always produce the desired results.
+- Always review generated commands before execution, especially when using the `-x` option.
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+This project is licensed under the MIT License.
+
+## Support
+
+If you encounter any issues or have questions, please file an issue on the GitHub repository.

data/bin/n2b

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require "n2b"
+
+N2B::CLI.run(ARGV)

data/lib/n2b/version.rb

@@ -0,0 +1,4 @@
+# lib/n2b/version.rb
+module N2B
+  VERSION = "0.1.0"
+end

data/lib/n2b.rb

@@ -0,0 +1,276 @@
+# lib/n2b.rb
+require "n2b/version"
+require 'net/http'
+require 'uri'
+require 'json'
+require 'optparse'
+require 'yaml'
+require 'fileutils'
+
+module N2B
+  class Error < StandardError; end
+
+  CONFIG_FILE = File.expand_path('~/.n2b/config.yml')
+  HISTORY_FILE = File.expand_path('~/.n2b/history')
+  MODELS = { 'haiku' =>  'claude-3-haiku-20240307', 'sonnet' => 'claude-3-sonnet-20240229', 'sonnet35' => 'claude-3-5-sonnet-20240620' }
+
+  class CLI
+    def self.run(args)
+      new(args).execute
+    end
+
+    def initialize(args)
+      @args = args
+      @options = parse_options
+    end
+
+    def execute
+      config = get_config(reconfigure: @options[:config])
+      input_text = @args.join(' ')
+      if input_text.empty?
+        puts "Enter your natural language command:"
+        input_text = $stdin.gets.chomp
+      end
+
+      bash_commands = call_llm(input_text, config)
+
+      puts "\nTranslated #{get_user_shell} Commands:"
+      puts "------------------------"
+      puts bash_commands['commands']
+      puts "------------------------"
+      if bash_commands['explanation']
+        puts "Explanation:" 
+        puts bash_commands['explanation']
+        puts "------------------------"
+      end 
+
+      if @options[:execute]
+        puts "Press Enter to execute these commands, or Ctrl+C to cancel."
+        $stdin.gets
+        system(bash_commands['commands'].join("\n"))
+      else
+        add_to_shell_history(bash_commands['commands'].join("\n")) if config['append_to_shell_history']
+      end
+    end
+
+    private
+
+    def load_config
+      if File.exist?(CONFIG_FILE)
+        YAML.load_file(CONFIG_FILE)
+      else
+        { }
+      end
+    end
+    
+    def get_config( reconfigure: false)
+      config = load_config
+      api_key = ENV['CLAUDE_API_KEY'] || config['access_key']
+      model = config['model'] || 'sonnet35'
+      if api_key.nil? || api_key == '' ||  reconfigure
+        print "Enter your Claude API key: #{ api_key.nil? || api_key.empty? ? '' : '(leave blank to keep the current key '+api_key[0..10]+'...)' }"
+        api_key = $stdin.gets.chomp 
+        api_key = config['access_key'] if api_key.empty?
+        print "Choose a model (haiku, sonnet, sonnet35 (default)): "
+        model = $stdin.gets.chomp 
+        model = 'sonnet35' if model.empty?
+        config['llm'] ||= 'anthropic'
+        config['access_key'] = api_key
+        config['model'] = model
+        unless MODELS.keys.include?(model)
+          puts "Invalid model. Choose from: #{MODELS.keys.join(', ')}"
+          exit 1
+        end
+        
+        config['privacy'] ||= {} 
+        print "Do you want to send your shell history to Claude? (y/n): "
+        config['privacy']['send_shell_history'] = $stdin.gets.chomp == 'y'
+        print "Do you want to send your past requests and answers to Claude? (y/n): "
+        config['privacy']['send_llm_history'] = $stdin.gets.chomp == 'y'
+        print "Do you want to send your current directory to Claude? (y/n): "
+        config['privacy']['send_current_directory'] = $stdin.gets.chomp == 'y'
+        print "Do you want to append the commands to your shell history? (y/n): "
+        config['append_to_shell_history'] = $stdin.gets.chomp == 'y'
+    
+        FileUtils.mkdir_p(File.dirname(CONFIG_FILE)) unless File.exist?(File.dirname(CONFIG_FILE))
+        File.open(CONFIG_FILE, 'w+') do |f|
+          f.write(config.to_yaml   )
+        end
+      end
+      
+      config
+    end
+    
+    def append_to_llm_history_file(commands)
+      File.open(HISTORY_FILE, 'a') do |file|
+        file.puts(commands)
+      end
+    end
+    
+    def read_llm_history_file
+      history = File.read(HISTORY_FILE) if File.exist?(HISTORY_FILE)
+      history || ''
+      # limit to 20 most recent commands
+      history.split("\n").last(20).join("\n")
+    end
+    
+    def call_llm(prompt, config)
+      uri = URI.parse('https://api.anthropic.com/v1/messages')
+      request = Net::HTTP::Post.new(uri)
+      request.content_type = 'application/json'
+      request['X-API-Key'] = config['access_key']
+      request['anthropic-version'] = '2023-06-01'
+      content = <<-EOF 
+              Translate the following natural language command to bash commands: #{prompt}\n\nProvide only the #{get_user_shell} commands for #{ get_user_os }. the commands should be separated by newlines. 
+              #{' the user is in directory'+Dir.pwd if config['privacy']['send_current_directory']}. 
+              #{' the user sent past requests to you and got these answers '+read_llm_history_file if config['privacy']['send_llm_history'] }
+              #{ "The user has this history for his shell. "+read_shell_history if config['privacy']['send_shell_history'] }
+              he is using #{File.basename(get_user_shell)} shell."
+              answer only with a valid json object with the key 'commands' and the value as a list of bash commands plus any additional information you want to provide in explanation.
+              { "commands": [ "echo 'Hello, World!'" ], "explanation": "This command prints 'Hello, World!' to the terminal."}
+              EOF
+    
+      request.body = JSON.dump({
+        "model" => MODELS[config['model']],
+        "max_tokens" => 1024,
+        "messages" => [
+          {
+            "role" => "user",
+            "content" => content 
+          }
+        ]
+      })
+    
+      response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+        http.request(request)
+      end
+      # check for errors
+      if response.code != '200'
+        puts "Error: #{response.code} #{response.message}"
+        puts response.body
+        exit 1
+      end
+      answer = JSON.parse(response.body)['content'].first['text'] 
+      begin 
+        # removee everything before the first { and after the last }
+        answer = answer.sub(/.*\{(.*)\}.*/m, '{\1}')
+        answer = JSON.parse(answer)
+      rescue JSON::ParserError
+        answer = { 'commands' => answer.split("\n"), explanation: answer}
+      end
+      append_to_llm_history_file("#{prompt}\n#{answer}")
+      answer
+    end
+    
+    def get_user_shell
+      ENV['SHELL'] || `getent passwd #{ENV['USER']}`.split(':')[6]
+    end
+
+    def get_user_os
+      case RbConfig::CONFIG['host_os']
+      when /mswin|msys|mingw|cygwin|bccwin|wince|emc/
+      :windows
+      when /darwin|mac os/
+      :macos
+      when /linux/
+      :linux
+      when /solaris|bsd/
+      :unix
+      else
+      :unknown
+      end
+    end
+    
+    def find_history_file(shell)
+      case shell
+      when 'zsh'
+        [
+          ENV['HISTFILE'],
+          File.expand_path('~/.zsh_history'),
+          File.expand_path('~/.zhistory')
+        ].find { |f| f && File.exist?(f) }
+      when 'bash'
+        [
+          ENV['HISTFILE'],
+          File.expand_path('~/.bash_history')
+        ].find { |f| f && File.exist?(f) }
+      else
+        nil
+      end
+    end
+    
+    def read_shell_history()
+      shell = File.basename(get_user_shell)
+      history_file = find_history_file(shell)
+      return '' unless history_file
+    
+      File.read(history_file)
+    end
+    
+    def add_to_shell_history(commands)
+      shell = File.basename(get_user_shell)
+      history_file = find_history_file(shell)
+    
+      unless history_file
+        puts "Could not find history file for #{shell}. Cannot add commands to history."
+        return
+      end
+    
+      case shell
+      when 'zsh'
+        add_to_zsh_history(commands, history_file)
+      when 'bash'
+        add_to_bash_history(commands, history_file)
+      else
+        puts "Unsupported shell: #{shell}. Cannot add commands to history."
+        return
+      end
+    
+      puts "Commands have been added to your #{shell} history file: #{history_file}"
+      puts "You may need to start a new shell session or reload your history to see the changes. #{ shell == 'zsh' ? 'For example, run `fc -R` in your zsh session.' : 'history -r for bash' }"
+      puts "Then you can access them using the up arrow key or Ctrl+R for reverse search."
+    end
+    
+    def add_to_zsh_history(commands, history_file)
+      File.open(history_file, 'a') do |file|
+        commands.each_line do |cmd|
+          timestamp = Time.now.to_i
+          file.puts(": #{timestamp}:0;#{cmd.strip}")
+        end
+      end
+    end
+    
+    def add_to_bash_history(commands, history_file)
+      File.open(history_file, 'a') do |file|
+        commands.each_line do |cmd|
+          file.puts(cmd.strip)
+        end
+      end
+      system("history -r") # Attempt to reload history in current session
+    end
+    
+
+    def parse_options
+      options = { execute: false, config: nil }
+
+      OptionParser.new do |opts|
+        opts.banner = "Usage: n2b [options] [natural language command]"
+
+        opts.on('-x', '--execute', 'Execute the commands after confirmation') do
+          options[:execute] = true
+        end
+
+        opts.on('-h', '--help', 'Print this help') do
+          puts opts
+          exit
+        end
+
+        opts.on('-c', '--config', 'Configure the API key and model') do
+          options[:config] = true
+        end
+      end.parse!(@args)
+
+      options
+    end
+  end
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: n2b
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Stefan Nothegger
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-07-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: A tool to convert natural language instructions to bash commands using
+  Claude API
+email:
+- stefan@kaproblem.com
+executables:
+- n2b
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bin/n2b
+- lib/n2b.rb
+- lib/n2b/version.rb
+homepage: https://github.com/stefan-kp/n2b
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.2
+signing_key:
+specification_version: 4
+summary: Convert natural language to bash commands
+test_files: []