code_sage 0.1.0

data/lib/code_sage/cli.rb

@@ -0,0 +1,161 @@
+require 'thor'
+require 'colorize'
+
+module CodeSage
+  class CLI < Thor
+    desc "review", "Review code changes in current repository"
+    option :branch, aliases: '-b', desc: "Branch to compare against (default: main)"
+    option :files, aliases: '-f', type: :array, desc: "Specific files to review"
+    option :format, aliases: '--format', default: 'console', desc: "Output format (console, json, markdown)"
+    option :config, aliases: '-c', desc: "Path to configuration file"
+    option :verbose, aliases: '-v', type: :boolean, desc: "Verbose output"
+    option :rag, type: :boolean, 
+                 desc: "Enable RAG (Retrieval Augmented Generation) functionality (requires vector database)"
+    def review
+      puts "🔮 CodeSage - Wisdom for your code".colorize(:cyan)
+      puts
+      
+      begin
+        reviewer = Reviewer.new(
+          branch: options[:branch] || 'main',
+          files: options[:files],
+          format: options[:format],
+          config_path: options[:config],
+          verbose: options[:verbose],
+          enable_rag: options[:rag] || false
+        )
+        
+        result = reviewer.review
+        
+        if result[:success]
+          puts "✅ Code review completed successfully!".colorize(:green)
+        else
+          puts "❌ Code review failed: #{result[:error]}".colorize(:red)
+          exit 1
+        end
+        
+      rescue => e
+        puts "💥 Error: #{e.message}".colorize(:red)
+        puts e.backtrace.join("\n").colorize(:yellow) if options[:verbose]
+        exit 1
+      end
+    end
+    
+    desc "config", "Show or set configuration"
+    option :show, type: :boolean, desc: "Show current configuration"
+    option :reset, type: :boolean, desc: "Reset configuration to defaults"
+    option :key, type: :string, desc: "Configuration key to set"
+    option :value, type: :string, desc: "Configuration value to set"
+    def config
+      config_instance = Config.new
+      
+      if options[:show]
+        puts "📋 CodeSage Configuration".colorize(:cyan).bold
+        puts "=" * 50
+        puts YAML.dump(config_instance.data)
+      elsif options[:reset]
+        config_instance.reset!
+        puts "✅ Configuration reset to defaults".colorize(:green)
+      elsif options[:key] && options[:value]
+        config_instance.set(options[:key], options[:value])
+        config_instance.save!
+        puts "✅ Configuration updated: #{options[:key]} = #{options[:value]}".colorize(:green)
+      else
+        puts "📋 Current configuration file: #{config_instance.config_path}".colorize(:cyan)
+        puts "Use --show to display configuration"
+        puts "Use --key KEY --value VALUE to update settings"
+        puts "Use --reset to restore defaults"
+      end
+    end
+    
+    desc "diagnose", "Run system diagnostics"
+    def diagnose
+      puts "🔍 CodeSage System Diagnostics".colorize(:cyan).bold
+      puts "=" * 50
+      
+      # Check Ruby version
+      print "Ruby: "
+      puts "✅ (#{RUBY_VERSION})".colorize(:green)
+      
+      # Check Git
+      print "Git: "
+      begin
+        git_version = `git --version 2>/dev/null`.strip
+        if $?.success?
+          puts "✅ (#{git_version})".colorize(:green)
+        else
+          puts "❌ Not found".colorize(:red)
+        end
+      rescue
+        puts "❌ Not found".colorize(:red)
+      end
+      
+      # Check llm_chain availability
+      print "LLMChain: "
+      begin
+        require 'llm_chain'
+        puts "✅ Available".colorize(:green)
+        
+        # Run llm_chain diagnostics if available
+        if defined?(LLMChain) && LLMChain.respond_to?(:diagnose_system)
+          puts "\n🔍 LLMChain Diagnostics:".colorize(:yellow)
+          LLMChain.diagnose_system
+        end
+      rescue LoadError
+        puts "❌ Not available".colorize(:red)
+        puts "   Run: gem install llm_chain".colorize(:yellow)
+      end
+      
+      # Check API Keys
+      puts "\n🔑 API Keys:".colorize(:yellow)
+      
+      api_keys = {
+        'OpenAI' => ENV['OPENAI_API_KEY'],
+        'Google' => ENV['GOOGLE_API_KEY'],
+        'Anthropic' => ENV['ANTHROPIC_API_KEY']
+      }
+      
+      api_keys.each do |name, key|
+        print "#{name}: "
+        if key && !key.empty?
+          puts "✅ Configured".colorize(:green)
+        else
+          puts "❌ Not set".colorize(:red)
+        end
+      end
+      
+      # Check configuration
+      puts "\n⚙️ Configuration:".colorize(:yellow)
+      config = Config.new
+      llm_config = config.data['llm']
+      
+      print "LLM Provider: "
+      puts "#{llm_config['provider'] || 'openai'}".colorize(:cyan)
+      
+      print "Model: "
+      puts "#{llm_config['model'] || 'gpt-4'}".colorize(:cyan)
+      
+      puts "\n💡 Recommendations:".colorize(:yellow)
+      recommendations = []
+      
+      recommendations << "• Configure API keys for your chosen LLM provider" unless api_keys.values.any? do |key|
+        key && !key.empty?
+      end
+      if llm_config['provider'] == 'ollama'
+        recommendations << "• Install and start Ollama for local models: ollama serve"
+      end
+      recommendations << "• Ensure you're in a Git repository for code review" unless Dir.exist?('.git')
+      
+      if recommendations.empty?
+        puts "✅ System looks good!".colorize(:green)
+      else
+        recommendations.each { |rec| puts rec }
+      end
+    end
+    
+    desc "version", "Show version"
+    def version
+      puts "CodeSage version #{CodeSage::VERSION}"
+    end
+  end
+end 

data/lib/code_sage/config.rb

@@ -0,0 +1,87 @@
+require 'yaml'
+
+module CodeSage
+  class Config
+    DEFAULT_CONFIG = {
+      'llm' => {
+        'provider' => 'openai',  # openai, ollama, qwen, gemini
+        'model' => 'gpt-4',
+        'temperature' => 0.1,
+        'max_tokens' => 2000,
+        'api_key' => nil  # Will use ENV variables
+      },
+      'git' => {
+        'default_branch' => 'main',
+        'include_patterns' => ['*.rb', '*.rake', 'Gemfile', 'Rakefile'],
+        'exclude_patterns' => ['spec/**/*', 'test/**/*']
+      },
+      'review' => {
+        'focus_areas' => ['security', 'performance', 'maintainability', 'best_practices'],
+        'severity_levels' => ['low', 'medium', 'high', 'critical']
+      },
+      'output' => {
+        'format' => 'console',
+        'verbose' => false,
+        'colors' => true
+      }
+    }.freeze
+    
+    attr_reader :config_path, :data
+    
+    def initialize(config_path = nil)
+      @config_path = config_path || default_config_path
+      @data = load_config
+    end
+    
+    def get(key_path)
+      keys = key_path.split('.')
+      keys.reduce(@data) { |config, key| config&.dig(key) }
+    end
+    
+    def set(key_path, value)
+      keys = key_path.split('.')
+      last_key = keys.pop
+      target = keys.reduce(@data) { |config, key| config[key] ||= {} }
+      target[last_key] = value
+    end
+    
+    def save!
+      File.write(@config_path, YAML.dump(@data))
+    end
+    
+    def reset!
+      @data = DEFAULT_CONFIG.dup
+      save!
+    end
+    
+    private
+    
+    def default_config_path
+      File.expand_path('~/.code_sage.yml')
+    end
+    
+    def load_config
+      if File.exist?(@config_path)
+        loaded = YAML.load_file(@config_path) || {}
+        deep_merge(DEFAULT_CONFIG, loaded)
+      else
+        DEFAULT_CONFIG.dup
+      end
+    rescue => e
+      puts "Warning: Could not load config file #{@config_path}: #{e.message}".colorize(:yellow)
+      DEFAULT_CONFIG.dup
+    end
+    
+    def deep_merge(hash1, hash2)
+      result = hash1.dup
+      hash2.each do |key, value|
+        if result[key].is_a?(Hash) && value.is_a?(Hash)
+          result[key] = deep_merge(result[key], value)
+        else
+          result[key] = value
+        end
+      end
+      result
+    end
+  end
+end 

data/lib/code_sage/git_analyzer.rb

@@ -0,0 +1,183 @@
+require 'rugged'
+
+module CodeSage
+  class GitAnalyzer
+    attr_reader :repo_path, :options
+    
+    def initialize(options = {})
+      @options = options
+      @repo_path = Dir.pwd
+      @repo = Rugged::Repository.new(@repo_path)
+    end
+    
+    def get_changes
+      if @options[:files]
+        analyze_specific_files(@options[:files])
+      else
+        analyze_branch_changes(@options[:branch])
+      end
+    end
+    
+    private
+    
+    def analyze_specific_files(files)
+      changes = []
+      
+      files.each do |file|
+        next unless File.exist?(file)
+        next unless ruby_file?(file)
+        
+        change = analyze_file(file)
+        changes << change if change
+      end
+      
+      changes
+    end
+    
+    def analyze_branch_changes(target_branch)
+      changes = []
+      
+      begin
+        # Get current HEAD
+        head = @repo.head.target
+        
+        # Get target branch
+        target = @repo.branches[target_branch]&.target || @repo.branches["origin/#{target_branch}"]&.target
+        
+        unless target
+          # If target branch doesn't exist, analyze staged changes
+          return analyze_staged_changes
+        end
+        
+        # Get diff between branches
+        diff = @repo.diff(target, head)
+        
+        diff.each_delta do |delta|
+          file_path = delta.new_file[:path]
+          next unless ruby_file?(file_path)
+          
+          change = {
+            file: file_path,
+            type: delta.status.to_s,
+            diff: get_file_diff(delta),
+            content: get_file_content(file_path),
+            lines_added: 0,
+            lines_removed: 0
+          }
+          
+          # Count lines
+          patch = diff.patch(delta)
+          if patch
+            change[:lines_added] = patch.scan(/^\+/).length
+            change[:lines_removed] = patch.scan(/^-/).length
+          end
+          
+          changes << change
+        end
+        
+      rescue => e
+        puts "Error analyzing git changes: #{e.message}".colorize(:red) if @options[:verbose]
+        # Fallback to staged changes
+        return analyze_staged_changes
+      end
+      
+      changes
+    end
+    
+    def analyze_staged_changes
+      changes = []
+      
+      # Get staged changes
+      index = @repo.index
+      diff = @repo.diff_index_to_workdir
+      
+      diff.each_delta do |delta|
+        file_path = delta.new_file[:path]
+        next unless ruby_file?(file_path)
+        
+        change = {
+          file: file_path,
+          type: delta.status.to_s,
+          diff: get_file_diff(delta),
+          content: get_file_content(file_path),
+          lines_added: 0,
+          lines_removed: 0
+        }
+        
+        # Count lines from patch
+        patch = diff.patch(delta)
+        if patch
+          change[:lines_added] = patch.scan(/^\+/).length
+          change[:lines_removed] = patch.scan(/^-/).length
+        end
+        
+        changes << change
+      end
+      
+      changes
+    rescue => e
+      puts "Error analyzing staged changes: #{e.message}".colorize(:red) if @options[:verbose]
+      []
+    end
+    
+    def analyze_file(file_path)
+      return nil unless File.exist?(file_path)
+      
+      {
+        file: file_path,
+        type: 'modified',
+        diff: get_simple_diff(file_path),
+        content: get_file_content(file_path),
+        lines_added: 0,
+        lines_removed: 0
+      }
+    end
+    
+    def get_file_diff(delta)
+      # Generate diff for the file
+      begin
+        patch = @repo.diff(delta.old_file[:oid], delta.new_file[:oid]).patch
+        patch.to_s
+      rescue
+        "Diff not available"
+      end
+    end
+    
+    def get_simple_diff(file_path)
+      # For single file analysis, return recent changes or full content
+      "Full file content (diff not available for single file analysis)"
+    end
+    
+    def get_file_content(file_path)
+      return nil unless File.exist?(file_path)
+      
+      File.read(file_path)
+    rescue => e
+      puts "Error reading file #{file_path}: #{e.message}".colorize(:red) if @options[:verbose]
+      nil
+    end
+    
+    def ruby_file?(file_path)
+      return false unless file_path
+      
+      ruby_extensions = %w[.rb .rake .gemspec]
+      ruby_files = %w[Gemfile Rakefile Guardfile]
+      
+      # Check extension
+      return true if ruby_extensions.any? { |ext| file_path.end_with?(ext) }
+      
+      # Check specific filenames
+      basename = File.basename(file_path)
+      return true if ruby_files.include?(basename)
+      
+      # Check if file starts with ruby shebang
+      if File.exist?(file_path)
+        first_line = File.open(file_path, &:readline).strip rescue ""
+        return true if first_line.start_with?('#!/usr/bin/env ruby') || 
+                      first_line.start_with?('#!/usr/bin/ruby')
+      end
+      
+      false
+    end
+  end
+end 

data/lib/code_sage/report_formatter.rb

@@ -0,0 +1,171 @@
+require 'json'
+require 'colorize'
+
+module CodeSage
+  class ReportFormatter
+    attr_reader :format
+    
+    def initialize(format = 'console')
+      @format = format.to_s.downcase
+    end
+    
+    def format(report)
+      case @format
+      when 'json'
+        format_json(report)
+      when 'markdown'
+        format_markdown(report)
+      else
+        format_console(report)
+      end
+    end
+    
+    private
+    
+    def format_console(report)
+      output = []
+      
+      # Header
+      output << "=" * 80
+      output << "🔮 CodeSage Review Report".colorize(:cyan).bold
+      output << "Generated at: #{report[:generated_at]}"
+      output << "=" * 80
+      output << ""
+      
+      # Summary
+      summary = report[:summary]
+      output << "📊 SUMMARY".colorize(:yellow).bold
+      output << "-" * 40
+      output << "Files reviewed: #{summary[:total_files_reviewed]}"
+      output << "Files with potential issues: #{summary[:files_with_issues]}"
+      output << "Total lines changed: #{summary[:total_lines_changed]}"
+      output << ""
+      
+      # Metrics
+      if report[:metrics]
+        metrics = report[:metrics]
+        output << "📈 METRICS".colorize(:yellow).bold  
+        output << "-" * 40
+        output << "Average lines per file: #{metrics[:avg_lines_per_file].round(1)}"
+        
+        if metrics[:files_by_type].any?
+          output << "Files by change type:"
+          metrics[:files_by_type].each do |type, count|
+            output << "  #{type}: #{count}"
+          end
+        end
+        output << ""
+      end
+      
+      # Individual reviews
+      output << "📝 DETAILED REVIEWS".colorize(:yellow).bold
+      output << "-" * 80
+      
+      report[:reviews].each_with_index do |review, index|
+        output << ""
+        output << "#{index + 1}. #{review[:file]}".colorize(:cyan).bold
+        output << "   Type: #{review[:change_type]} | +#{review[:lines_added]} -#{review[:lines_removed]}"
+        output << "   " + "-" * 70
+        
+        # Format review content
+        review_lines = review[:review].split("\n")
+        review_lines.each do |line|
+          if line.match(/^(Issue|Problem|Warning):/i)
+            output << "   #{line}".colorize(:red)
+          elsif line.match(/^(Suggestion|Recommendation):/i)
+            output << "   #{line}".colorize(:yellow)
+          elsif line.match(/^(Good|Positive):/i)
+            output << "   #{line}".colorize(:green)
+          else
+            output << "   #{line}"
+          end
+        end
+      end
+      
+      # Recommendations
+      if report[:recommendations]&.any?
+        output << ""
+        output << "💡 RECOMMENDATIONS".colorize(:yellow).bold
+        output << "-" * 40
+        report[:recommendations].each_with_index do |rec, index|
+          output << "#{index + 1}. #{rec}"
+        end
+      end
+      
+      output << ""
+      output << "=" * 80
+      
+      output.join("\n")
+    end
+    
+    def format_json(report)
+      JSON.pretty_generate(report)
+    end
+    
+    def format_markdown(report)
+      output = []
+      
+      # Header
+      output << "# 🔮 CodeSage Review Report"
+      output << ""
+      output << "**Generated at:** #{report[:generated_at]}"
+      output << ""
+      
+      # Summary
+      summary = report[:summary]
+      output << "## 📊 Summary"
+      output << ""
+      output << "| Metric | Value |"
+      output << "|--------|-------|"
+      output << "| Files reviewed | #{summary[:total_files_reviewed]} |"
+      output << "| Files with potential issues | #{summary[:files_with_issues]} |"
+      output << "| Total lines changed | #{summary[:total_lines_changed]} |"
+      output << ""
+      
+      # Metrics
+      if report[:metrics]
+        metrics = report[:metrics]
+        output << "## 📈 Metrics"
+        output << ""
+        output << "- **Average lines per file:** #{metrics[:avg_lines_per_file].round(1)}"
+        
+        if metrics[:files_by_type].any?
+          output << "- **Files by change type:**"
+          metrics[:files_by_type].each do |type, count|
+            output << "  - #{type}: #{count}"
+          end
+        end
+        output << ""
+      end
+      
+      # Individual reviews
+      output << "## 📝 Detailed Reviews"
+      output << ""
+      
+      report[:reviews].each_with_index do |review, index|
+        output << "### #{index + 1}. `#{review[:file]}`"
+        output << ""
+        change_info = "**Change Type:** #{review[:change_type]} | " \
+                      "**Lines:** +#{review[:lines_added]} -#{review[:lines_removed]}"
+        output << change_info
+        output << ""
+        output << "```"
+        output << review[:review]
+        output << "```"
+        output << ""
+      end
+      
+      # Recommendations
+      if report[:recommendations]&.any?
+        output << "## 💡 Recommendations"
+        output << ""
+        report[:recommendations].each_with_index do |rec, index|
+          output << "#{index + 1}. #{rec}"
+        end
+        output << ""
+      end
+      
+      output.join("\n")
+    end
+  end
+end