reposer 1.1.0

data/lib/repose/ai/gemini_provider.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+
+module Repose
+  module AI
+    class GeminiProvider
+      API_ENDPOINT = "https://generativelanguage.googleapis.com/v1beta/models"
+      DEFAULT_MODEL = "gemini-1.5-flash"
+      MAX_RETRIES = 3
+      TIMEOUT = 30
+
+      attr_reader :api_key, :model
+
+      def initialize(api_key: nil, model: DEFAULT_MODEL)
+        @api_key = api_key || ENV["GEMINI_API_KEY"]
+        @model = model
+        
+        raise Repose::ConfigurationError, "Gemini API key not configured" if @api_key.nil? || @api_key.empty?
+      end
+
+      def generate_description(context)
+        prompt = build_description_prompt(context)
+        response = call_api(prompt, max_tokens: 100)
+        clean_response(response)
+      end
+
+      def generate_topics(context)
+        prompt = build_topics_prompt(context)
+        response = call_api(prompt, max_tokens: 50)
+        parse_topics(response)
+      end
+
+      def generate_readme(context)
+        prompt = build_readme_prompt(context)
+        response = call_api(prompt, max_tokens: 1000)
+        clean_response(response)
+      end
+
+      def available?
+        return false if @api_key.nil? || @api_key.empty?
+        
+        # Quick health check
+        uri = URI("#{API_ENDPOINT}/#{model}?key=#{api_key}")
+        request = Net::HTTP::Get.new(uri)
+        
+        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true, open_timeout: 5, read_timeout: 5) do |http|
+          http.request(request)
+        end
+        
+        response.is_a?(Net::HTTPSuccess)
+      rescue StandardError
+        false
+      end
+
+      private
+
+      def call_api(prompt, max_tokens: 500, temperature: 0.7)
+        uri = URI("#{API_ENDPOINT}/#{model}:generateContent?key=#{api_key}")
+        
+        payload = {
+          contents: [
+            {
+              parts: [
+                { text: prompt }
+              ]
+            }
+          ],
+          generationConfig: {
+            temperature: temperature,
+            maxOutputTokens: max_tokens,
+            topP: 0.95,
+            topK: 40
+          }
+        }
+
+        retries = 0
+        begin
+          request = Net::HTTP::Post.new(uri)
+          request["Content-Type"] = "application/json"
+          request.body = payload.to_json
+
+          response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true, 
+                                     open_timeout: TIMEOUT, read_timeout: TIMEOUT) do |http|
+            http.request(request)
+          end
+
+          handle_response(response)
+        rescue Net::OpenTimeout, Net::ReadTimeout => e
+          retries += 1
+          raise Repose::APIError, "Gemini API timeout: #{e.message}" if retries > MAX_RETRIES
+          
+          sleep(2**retries) # Exponential backoff
+          retry
+        rescue StandardError => e
+          raise Repose::APIError, "Gemini API error: #{e.message}"
+        end
+      end
+
+      def handle_response(response)
+        case response
+        when Net::HTTPSuccess
+          body = JSON.parse(response.body)
+          extract_text_from_response(body)
+        when Net::HTTPUnauthorized
+          raise Repose::AuthenticationError, "Invalid Gemini API key"
+        when Net::HTTPTooManyRequests
+          raise Repose::RateLimitError, "Gemini API rate limit exceeded"
+        else
+          raise Repose::APIError, "Gemini API error (#{response.code}): #{response.body}"
+        end
+      end
+
+      def extract_text_from_response(body)
+        return "" unless body.dig("candidates", 0, "content", "parts", 0, "text")
+        
+        body.dig("candidates", 0, "content", "parts", 0, "text").strip
+      end
+
+      def build_description_prompt(context)
+        <<~PROMPT
+          Generate a concise, professional GitHub repository description (max 100 characters) for:
+          
+          Repository name: #{context[:name]}
+          Language: #{context[:language]}
+          Framework: #{context[:framework]}
+          Purpose: #{context[:purpose]}
+          
+          Return only the description text, no quotes or extra formatting.
+        PROMPT
+      end
+
+      def build_topics_prompt(context)
+        <<~PROMPT
+          Generate 5-8 relevant GitHub topics (keywords) for this repository:
+          
+          Repository name: #{context[:name]}
+          Language: #{context[:language]}
+          Framework: #{context[:framework]}
+          Purpose: #{context[:purpose]}
+          
+          Return topics as comma-separated lowercase words (e.g., javascript, react, api, nodejs).
+          No quotes, no explanations, just the comma-separated list.
+        PROMPT
+      end
+
+      def build_readme_prompt(context)
+        title = context[:name].split(/[-_]/).map(&:capitalize).join(" ")
+        
+        <<~PROMPT
+          Generate a comprehensive README.md for a GitHub repository with these details:
+          
+          Repository name: #{context[:name]} (Title: #{title})
+          Language: #{context[:language]}
+          Framework: #{context[:framework]}
+          Purpose: #{context[:purpose]}
+          
+          Include these sections:
+          - Title and brief description
+          - Features (3-5 bullet points)
+          - Installation instructions (language-specific)
+          - Usage examples with code blocks
+          - Contributing guidelines
+          - License (MIT)
+          
+          Use proper Markdown formatting. Be concise and professional.
+          Return only the README content, no extra commentary.
+        PROMPT
+      end
+
+      def clean_response(text)
+        return "" if text.nil? || text.empty?
+        
+        # Remove common markdown artifacts
+        text.gsub(/^```\w*\n/, "")
+            .gsub(/\n```$/, "")
+            .strip
+      end
+
+      def parse_topics(text)
+        return [] if text.nil? || text.empty?
+        
+        # Split by commas and clean up
+        topics = text.split(",").map(&:strip).map(&:downcase)
+        
+        # Remove duplicates and limit to 8
+        topics.uniq.first(8)
+      end
+    end
+  end
+end

data/lib/repose/ai/ollama_provider.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+
+module Repose
+  module AI
+    class OllamaProvider
+      DEFAULT_ENDPOINT = "http://localhost:11434"
+      DEFAULT_MODEL = "mistral"
+      MAX_RETRIES = 2
+      TIMEOUT = 45
+
+      attr_reader :endpoint, :model
+
+      def initialize(endpoint: nil, model: nil)
+        @endpoint = endpoint || ENV["OLLAMA_ENDPOINT"] || DEFAULT_ENDPOINT
+        @model = model || ENV["OLLAMA_MODEL"] || DEFAULT_MODEL
+      end
+
+      def generate_description(context)
+        prompt = build_description_prompt(context)
+        response = call_api(prompt, max_tokens: 100)
+        clean_response(response)
+      end
+
+      def generate_topics(context)
+        prompt = build_topics_prompt(context)
+        response = call_api(prompt, max_tokens: 50)
+        parse_topics(response)
+      end
+
+      def generate_readme(context)
+        prompt = build_readme_prompt(context)
+        response = call_api(prompt, max_tokens: 2000)
+        clean_response(response)
+      end
+
+      def available?
+        list_models.any?
+      rescue StandardError
+        false
+      end
+
+      def list_models
+        uri = URI("#{endpoint}/api/tags")
+        request = Net::HTTP::Get.new(uri)
+
+        response = Net::HTTP.start(uri.hostname, uri.port, 
+                                   open_timeout: 5, read_timeout: 5) do |http|
+          http.request(request)
+        end
+
+        return [] unless response.is_a?(Net::HTTPSuccess)
+
+        body = JSON.parse(response.body)
+        body["models"]&.map { |m| m["name"] } || []
+      rescue StandardError
+        []
+      end
+
+      def pull_model(model_name = @model)
+        uri = URI("#{endpoint}/api/pull")
+        request = Net::HTTP::Post.new(uri)
+        request["Content-Type"] = "application/json"
+        request.body = { name: model_name }.to_json
+
+        response = Net::HTTP.start(uri.hostname, uri.port, 
+                                   open_timeout: 300, read_timeout: 300) do |http|
+          http.request(request)
+        end
+
+        response.is_a?(Net::HTTPSuccess)
+      rescue StandardError => e
+        raise Repose::APIError, "Failed to pull Ollama model: #{e.message}"
+      end
+
+      private
+
+      def call_api(prompt, max_tokens: 500, temperature: 0.7)
+        uri = URI("#{endpoint}/api/generate")
+        
+        payload = {
+          model: model,
+          prompt: prompt,
+          stream: false,
+          options: {
+            temperature: temperature,
+            num_predict: max_tokens,
+            top_p: 0.9,
+            top_k: 40
+          }
+        }
+
+        retries = 0
+        begin
+          request = Net::HTTP::Post.new(uri)
+          request["Content-Type"] = "application/json"
+          request.body = payload.to_json
+
+          response = Net::HTTP.start(uri.hostname, uri.port, 
+                                     open_timeout: TIMEOUT, read_timeout: TIMEOUT) do |http|
+            http.request(request)
+          end
+
+          handle_response(response)
+        rescue Net::OpenTimeout, Net::ReadTimeout => e
+          retries += 1
+          raise Repose::APIError, "Ollama timeout: #{e.message}" if retries > MAX_RETRIES
+          
+          sleep(3 * retries) # Linear backoff
+          retry
+        rescue Errno::ECONNREFUSED
+          raise Repose::APIError, "Cannot connect to Ollama at #{endpoint}. Is Ollama running?"
+        rescue StandardError => e
+          raise Repose::APIError, "Ollama error: #{e.message}"
+        end
+      end
+
+      def handle_response(response)
+        case response
+        when Net::HTTPSuccess
+          body = JSON.parse(response.body)
+          body["response"]&.strip || ""
+        when Net::HTTPNotFound
+          raise Repose::APIError, "Ollama model '#{model}' not found. Run: ollama pull #{model}"
+        else
+          raise Repose::APIError, "Ollama error (#{response.code}): #{response.body}"
+        end
+      end
+
+      def build_description_prompt(context)
+        <<~PROMPT
+          Generate a concise GitHub repository description (max 100 characters) for:
+          
+          Repository: #{context[:name]}
+          Language: #{context[:language]}
+          Framework: #{context[:framework]}
+          Purpose: #{context[:purpose]}
+          
+          Return ONLY the description text with no quotes or formatting.
+        PROMPT
+      end
+
+      def build_topics_prompt(context)
+        <<~PROMPT
+          Generate 5-8 GitHub topics for:
+          
+          Repository: #{context[:name]}
+          Language: #{context[:language]}
+          Framework: #{context[:framework]}
+          Purpose: #{context[:purpose]}
+          
+          Return ONLY comma-separated lowercase keywords (e.g., python, api, docker, cli).
+        PROMPT
+      end
+
+      def build_readme_prompt(context)
+        title = context[:name].split(/[-_]/).map(&:capitalize).join(" ")
+        
+        <<~PROMPT
+          Create a GitHub README.md for:
+          
+          Repository: #{context[:name]} (Display as: #{title})
+          Language: #{context[:language]}
+          Framework: #{context[:framework]}
+          Purpose: #{context[:purpose]}
+          
+          Include:
+          - Title (# #{title})
+          - Brief description
+          - Features (3-5 bullet points)
+          - Installation (#{context[:language]}-specific commands)
+          - Usage with code examples
+          - Contributing
+          - MIT License
+          
+          Use proper Markdown. Return ONLY the README content.
+        PROMPT
+      end
+
+      def clean_response(text)
+        return "" if text.nil? || text.empty?
+        
+        # Remove common artifacts
+        text.gsub(/^Here's.*?:\s*/i, "")
+            .gsub(/^```\w*\n/, "")
+            .gsub(/\n```$/, "")
+            .strip
+      end
+
+      def parse_topics(text)
+        return [] if text.nil? || text.empty?
+        
+        # Extract comma-separated values
+        topics = text.split(",").map(&:strip).map(&:downcase)
+        
+        # Remove duplicates, filter out empty, limit to 8
+        topics.reject(&:empty?).uniq.first(8)
+      end
+    end
+  end
+end

data/lib/repose/ai_generator.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+require_relative "ai/gemini_provider"
+require_relative "ai/ollama_provider"
+
+module Repose
+  class AIGenerator
+    attr_reader :provider
+
+    def initialize(provider: nil)
+      @provider = select_provider(provider)
+    end
+
+    def generate(context)
+      {
+        name: context[:name],
+        description: generate_description(context),
+        topics: generate_topics(context),
+        readme: generate_readme(context)
+      }
+    end
+
+    def use_ai?
+      !@provider.nil?
+    end
+
+    private
+
+    def select_provider(provider_name)
+      return nil if provider_name == :none || provider_name == false
+
+      case provider_name&.to_sym
+      when :gemini
+        AI::GeminiProvider.new if gemini_available?
+      when :ollama
+        AI::OllamaProvider.new if ollama_available?
+      when nil
+        # Auto-detect: prefer Gemini, fallback to Ollama, then none
+        if gemini_available?
+          AI::GeminiProvider.new
+        elsif ollama_available?
+          AI::OllamaProvider.new
+        end
+      else
+        raise ArgumentError, "Unknown AI provider: #{provider_name}"
+      end
+    rescue Repose::ConfigurationError, Repose::APIError
+      nil # Fallback to template-based generation
+    end
+
+    def gemini_available?
+      return false unless ENV["GEMINI_API_KEY"]
+      
+      AI::GeminiProvider.new.available?
+    rescue StandardError
+      false
+    end
+
+    def ollama_available?
+      AI::OllamaProvider.new.available?
+    rescue StandardError
+      false
+    end
+
+    def generate_description(context)
+      if use_ai?
+        @provider.generate_description(context)
+      else
+        generate_fallback_description(context)
+      end
+    rescue Repose::APIError, Repose::AuthenticationError
+      generate_fallback_description(context)
+    end
+
+    def generate_topics(context)
+      if use_ai?
+        @provider.generate_topics(context)
+      else
+        generate_fallback_topics(context)
+      end
+    rescue Repose::APIError, Repose::AuthenticationError
+      generate_fallback_topics(context)
+    end
+
+    def generate_readme(context)
+      if use_ai?
+        @provider.generate_readme(context)
+      else
+        generate_fallback_readme(context)
+      end
+    rescue Repose::APIError, Repose::AuthenticationError
+      generate_fallback_readme(context)
+    end
+
+    def generate_fallback_description(context)
+      # Fallback description generation without AI
+      base_desc = "A #{context[:language]}"
+      base_desc += " #{context[:framework]}" if context[:framework]
+      base_desc += " project"
+      base_desc += " for #{context[:purpose]}" if context[:purpose] && !context[:purpose].empty?
+      
+      base_desc.capitalize
+    end
+
+    def generate_fallback_topics(context)
+      # Basic topic generation without AI
+      topics = []
+      topics << context[:language].downcase if context[:language]
+      topics << context[:framework].downcase if context[:framework]
+      
+      # Add some common topics based on name patterns
+      name_lower = context[:name].downcase
+      topics << "api" if name_lower.include?("api")
+      topics << "web" if name_lower.include?("web") || context[:framework]&.downcase&.include?("rails")
+      topics << "cli" if name_lower.include?("cli") || name_lower.include?("command")
+      topics << "tool" if name_lower.include?("tool") || name_lower.include?("util")
+      
+      topics.uniq.first(8)
+    end
+
+    def generate_fallback_readme(context)
+      title = context[:name].split(/[-_]/).map(&:capitalize).join(" ")
+      
+      <<~README
+        # #{title}
+
+        A #{context[:language]} #{context[:framework] ? "#{context[:framework]} " : ""}project#{context[:purpose] && !context[:purpose].empty? ? " for #{context[:purpose]}" : ""}.
+
+        ## Installation
+
+        ```bash
+        git clone https://github.com/yourusername/#{context[:name]}.git
+        cd #{context[:name]}
+        ```
+
+        #{language_specific_install_instructions(context[:language])}
+
+        ## Usage
+
+        More documentation coming soon!
+
+        ## Contributing
+
+        1. Fork the repository
+        2. Create a feature branch
+        3. Make your changes
+        4. Submit a pull request
+
+        ## License
+
+        This project is licensed under the MIT License.
+      README
+    end
+
+    def language_specific_install_instructions(language)
+      case language&.downcase
+      when "ruby"
+        "```bash\nbundle install\n```"
+      when "python"
+        "```bash\npip install -r requirements.txt\n```"
+      when "javascript", "typescript"
+        "```bash\nnpm install\n```"
+      when "go"
+        "```bash\ngo mod download\n```"
+      when "rust"
+        "```bash\ncargo build\n```"
+      else
+        ""
+      end
+    end
+  end
+end