fantasy-cli 1.2.6

data/lib/gsd/ai/config.rb

@@ -0,0 +1,256 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'fileutils'
+
+module Gsd
+  module AI
+    # Config CLI - Comando para configurar API keys
+    #
+    # Uso:
+    #   gsd ai config set openrouter <api-key>
+    #   gsd ai config get openrouter
+    #   gsd ai config list
+    class ConfigCLI
+      attr_reader :config_dir, :config_file
+
+      # Inicializa o config CLI
+      #
+      # @param cwd [String] Diretório de trabalho
+      def initialize(cwd: Dir.pwd)
+        @cwd = cwd
+        @config_dir = File.join(cwd, '.gsd')
+        @config_file = File.join(@config_dir, 'config.json')
+
+        ensure_config_dir
+      end
+
+      # Define uma API key
+      #
+      # @param provider [String] Nome do provider
+      # @param api_key [String] API key
+      # @return [void]
+      def set_key(provider, api_key)
+        config = load_config
+        config['api_keys'] ||= {}
+        config['api_keys'][provider] = api_key
+        save_config(config)
+
+        puts "✅ API key de #{provider} configurada!"
+
+        # Sugere exportar para variável de ambiente
+        env_var = "#{provider.upcase}_API_KEY"
+        puts "\nDica: Exporte para variável de ambiente:"
+        puts "  export #{env_var}=#{api_key[0..10]}..."
+      end
+
+      # Obtém uma API key
+      #
+      # @param provider [String] Nome do provider
+      # @return [String, nil] API key
+      def get_key(provider)
+        # Tenta variável de ambiente primeiro
+        env_var = "#{provider.upcase}_API_KEY"
+        return ENV[env_var] if ENV[env_var]
+
+        # Tenta config file
+        config = load_config
+        config['api_keys']&.[](provider)
+      end
+
+      # Lista todas as API keys configuradas
+      #
+      # @return [void]
+      def list_keys
+        config = load_config
+        api_keys = config['api_keys'] || {}
+
+        # Adiciona variáveis de ambiente
+        env_keys = {
+          'anthropic' => ENV['ANTHROPIC_API_KEY'],
+          'openai' => ENV['OPENAI_API_KEY'],
+          'openrouter' => ENV['OPENROUTER_API_KEY'],
+          'ollama' => 'local (não requer key)',
+          'lmstudio' => 'local (não requer key)'
+        }
+
+        puts "\n🔑 API Keys Configuradas\n"
+        puts "=" * 50
+
+        env_keys.each do |provider, key|
+          status = key ? '✅' : '❌'
+          masked = key ? "#{key[0..10]}..." : 'Não configurada'
+          puts "#{status} #{provider.ljust(12)} : #{masked}"
+        end
+
+        api_keys.each do |provider, key|
+          next if env_keys[provider] # Já listado
+
+          status = '✅ (config file)'
+          masked = "#{key[0..10]}..."
+          puts "#{status} #{provider.ljust(12)} : #{masked}"
+        end
+
+        puts "=" * 50
+        puts "\nDica: Use variáveis de ambiente para maior segurança:"
+        puts "  export OPENROUTER_API_KEY=sk-or-..."
+        puts "  export ANTHROPIC_API_KEY=sk-ant-..."
+        puts "  export OPENAI_API_KEY=sk-..."
+        puts
+      end
+
+      # Remove uma API key
+      #
+      # @param provider [String] Nome do provider
+      # @return [void]
+      def remove_key(provider)
+        config = load_config
+        if config['api_keys']&.delete(provider)
+          save_config(config)
+          puts "✅ API key de #{provider} removida!"
+        else
+          puts "⚠️  API key de #{provider} não encontrada!"
+        end
+      end
+
+      # Verifica se provider está configurado
+      #
+      # @param provider [String] Nome do provider
+      # @return [Boolean] true se configurado
+      def configured?(provider)
+        !get_key(provider).nil?
+      end
+
+      # Executa o comando config
+      #
+      # @param args [Array] Argumentos
+      # @return [void]
+      def run(args = [])
+        subcommand = args.shift
+
+        case subcommand
+        when 'set'
+          provider = args.shift
+          api_key = args.shift
+
+          unless provider && api_key
+            puts "❌ Uso: gsd ai config set <provider> <api-key>"
+            exit 1
+          end
+
+          set_key(provider, api_key)
+
+        when 'get'
+          provider = args.shift
+
+          unless provider
+            puts "❌ Uso: gsd ai config get <provider>"
+            exit 1
+          end
+
+          key = get_key(provider)
+          if key
+            puts "#{provider}: #{key[0..10]}..."
+          else
+            puts "❌ API key de #{provider} não configurada!"
+            puts "\nConfigure com:"
+            puts "  gsd ai config set #{provider} <api-key>"
+            exit 1
+          end
+
+        when 'list', nil
+          list_keys
+
+        when 'remove', 'rm'
+          provider = args.shift
+
+          unless provider
+            puts "❌ Uso: gsd ai config remove <provider>"
+            exit 1
+          end
+
+          remove_key(provider)
+
+        when 'help', '--help', '-h'
+          print_help
+
+        else
+          puts "❌ Subcomando desconhecido: #{subcommand}"
+          print_help
+          exit 1
+        end
+      end
+
+      private
+
+      # Garante que diretório de config existe
+      #
+      # @return [void]
+      def ensure_config_dir
+        FileUtils.mkdir_p(@config_dir) unless File.directory?(@config_dir)
+      end
+
+      # Carrega config do arquivo
+      #
+      # @return [Hash] Config
+      def load_config
+        return {} unless File.exist?(@config_file)
+
+        JSON.parse(File.read(@config_file))
+      rescue => e
+        warn "[Config] Erro ao carregar: #{e.message}"
+        {}
+      end
+
+      # Salva config no arquivo
+      #
+      # @param config [Hash] Config
+      # @return [void]
+      def save_config(config)
+        File.write(@config_file, JSON.pretty_generate(config))
+
+        # Define permissões seguras (Unix)
+        File.chmod(0600, @config_file) if File.respond_to?(:chmod)
+      end
+
+      # Imprime ajuda
+      #
+      # @return [void]
+      def print_help
+        puts <<~HELP
+
+          GSD AI Config - Gerencie suas API keys
+
+          USO:
+            gsd ai config <subcommand> [args]
+
+          SUBCOMANDOS:
+            set <provider> <key>   Configurar API key
+            get <provider>         Obter API key configurada
+            list                   Listar todas API keys
+            remove <provider>      Remover API key
+            help                   Mostrar esta ajuda
+
+          EXEMPLOS:
+            gsd ai config set openrouter sk-or-v1-...
+            gsd ai config get openrouter
+            gsd ai config list
+            gsd ai config remove openrouter
+
+          PROVIDERS:
+            anthropic    - Anthropic Claude
+            openai       - OpenAI GPT
+            openrouter   - OpenRouter (Qwen, Llama, etc.)
+            ollama       - Ollama (local)
+            lmstudio     - LM Studio (local)
+
+          VARIÁVEIS DE AMBIENTE:
+            OPENROUTER_API_KEY   - OpenRouter API key
+            ANTHROPIC_API_KEY    - Anthropic API key
+            OPENAI_API_KEY       - OpenAI API key
+
+        HELP
+      end
+    end
+  end
+end

data/lib/gsd/ai/context.rb

@@ -0,0 +1,324 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'digest/md5'
+require 'fileutils'
+require 'time'
+require 'gsd/state'
+require 'gsd/phase'
+require 'gsd/roadmap'
+require 'gsd/ai/git_context'
+
+module Gsd
+  module AI
+    # Context Management - Gerencia contexto do projeto para a IA
+    #
+    # Responsável por:
+    # - Carregar estado atual do projeto
+    # - Carregar phase atual
+    # - Carregar roadmap
+    # - Carregar todos e commits recentes
+    # - Cache com TTL e invalidação por hash
+    # - Persistência de contexto em disco
+    class Context
+      attr_reader :cwd, :cache_ttl
+
+      # Inicializa o contexto
+      #
+      # @param cwd [String] Diretório de trabalho
+      # @param cache_ttl [Integer] TTL do cache em segundos (default: 300)
+      # @param cache_dir [String] Diretório para cache persistente
+      def initialize(cwd: Dir.pwd, cache_ttl: 300, cache_dir: nil)
+        @cwd = cwd
+        @cache_ttl = cache_ttl
+        @cache_dir = cache_dir || File.join(@cwd, '.gsd', 'cache')
+        @cache = {}
+        @cache_timestamps = {}
+        @cache_hashes = {}
+
+        ensure_cache_dir
+      end
+
+      # Carrega todo o contexto do projeto
+      #
+      # @param force [Boolean] Forçar recarregamento (ignora cache)
+      # @return [Hash] Dados de contexto
+      def load(force: false)
+        if force || expired?
+          reload
+        else
+          # Verifica se o conteúdo mudou (hash-based cache)
+          current_hash = compute_context_hash
+          if @cache_hashes[:context] != current_hash
+            reload
+          end
+        end
+
+        @cache
+      end
+
+      # Recarrega o contexto (invalida cache)
+      #
+      # @return [Hash] Dados de contexto
+      def reload
+        log_debug("Reloading context...")
+
+        @cache = {}
+        @cache_timestamps[:loaded_at] = Time.now
+
+        @cache[:state] = load_state
+        @cache[:current_phase] = load_current_phase(@cache[:state])
+        @cache[:roadmap] = load_roadmap
+        @cache[:todos] = load_todos
+        @cache[:recent_commits] = load_recent_commits
+        @cache[:git] = load_git_context
+        @cache[:loaded_at] = @cache_timestamps[:loaded_at]&.iso8601
+
+        # Computa e salva hash do contexto
+        @cache_hashes[:context] = compute_context_hash
+
+        # Persiste cache em disco
+        save_cache_to_disk
+
+        log_debug("Context reloaded. Hash: #{@cache_hashes[:context][0..8]}")
+
+        @cache
+      end
+
+      # Retorna o tamanho do contexto em KB
+      #
+      # @return [Integer] Tamanho em KB
+      def size
+        JSON.generate(@cache).bytesize / 1024
+      end
+
+      # Verifica se o contexto é válido
+      #
+      # @return [Boolean] true se contexto é válido
+      def valid?
+        load
+        !@cache[:state].nil? && !@cache[:state].empty?
+      end
+
+      # Retorna idade do cache em segundos
+      #
+      # @return [Integer] Idade em segundos
+      def cache_age
+        return 0 unless @cache_timestamps[:loaded_at]
+
+        (Time.now - @cache_timestamps[:loaded_at]).to_i
+      end
+
+      # Retorna informações do cache
+      #
+      # @return [Hash] Informações do cache
+      def cache_info
+        {
+          loaded_at: @cache_timestamps[:loaded_at]&.iso8601,
+          age_seconds: cache_age,
+          ttl_seconds: @cache_ttl,
+          expired: expired?,
+          hash: @cache_hashes[:context],
+          size_kb: size
+        }
+      end
+
+      # Limpa o cache
+      #
+      # @return [void]
+      def clear_cache
+        @cache = {}
+        @cache_timestamps = {}
+        @cache_hashes = {}
+        delete_cache_from_disk
+      end
+
+      # Exporta contexto para JSON
+      #
+      # @return [String] JSON do contexto
+      def to_json
+        JSON.pretty_generate(@cache)
+      end
+
+      # Importa contexto de JSON
+      #
+      # @param json [String] JSON do contexto
+      # @return [void]
+      def from_json(json)
+        @cache = JSON.parse(json, symbolize_names: true)
+        @cache_timestamps[:loaded_at] = Time.parse(@cache[:loaded_at]) if @cache[:loaded_at]
+        @cache_hashes[:context] = compute_context_hash
+      end
+
+      private
+
+      # Verifica se cache expirou
+      #
+      # @return [Boolean] true se expirado
+      def expired?
+        return true if @cache_ttl.nil? || @cache_ttl <= 0
+        return true unless @cache_timestamps[:loaded_at]
+
+        cache_age >= @cache_ttl
+      end
+
+      # Computa hash do contexto para detecção de mudanças
+      #
+      # @return [String] Hash MD5 do contexto
+      def compute_context_hash
+        content = ""
+        content += File.read(File.join(@cwd, '.planning', 'STATE.md')) rescue ""
+        content += Dir.glob(File.join(@cwd, '.planning', 'phases', '**', '*.md')).sort.map { |f| File.read(f) }.join("\n") rescue ""
+        content += File.read(File.join(@cwd, '.planning', 'ROADMAP.md')) rescue ""
+
+        Digest::MD5.hexdigest(content)
+      end
+
+      # Garante que diretório de cache existe
+      #
+      # @return [void]
+      def ensure_cache_dir
+        FileUtils.mkdir_p(@cache_dir) unless File.directory?(@cache_dir)
+      end
+
+      # Salva cache em disco
+      #
+      # @return [void]
+      def save_cache_to_disk
+        cache_file = File.join(@cache_dir, 'context.json')
+        File.write(cache_file, to_json)
+        log_debug("Cache saved to #{cache_file}")
+      rescue => e
+        log_debug("Failed to save cache: #{e.message}")
+      end
+
+      # Carrega cache do disco
+      #
+      # @return [Hash,nil] Cache carregado ou nil
+      def load_cache_from_disk
+        cache_file = File.join(@cache_dir, 'context.json')
+        return nil unless File.exist?(cache_file)
+
+        json = File.read(cache_file)
+        JSON.parse(json, symbolize_names: true)
+      rescue => e
+        log_debug("Failed to load cache: #{e.message}")
+        nil
+      end
+
+      # Deleta cache do disco
+      #
+      # @return [void]
+      def delete_cache_from_disk
+        cache_file = File.join(@cache_dir, 'context.json')
+        File.delete(cache_file) if File.exist?(cache_file)
+      rescue => e
+        log_debug("Failed to delete cache: #{e.message}")
+      end
+
+      # Carrega estado do projeto
+      #
+      # @return [Hash] Dados do estado
+      def load_state
+        Gsd::State.json(cwd: @cwd)
+      rescue => e
+        warn "[Context] Erro ao carregar state: #{e.message}"
+        {}
+      end
+
+      # Carrega phase atual
+      #
+      # @param state [Hash] Estado do projeto (opcional)
+      # @return [Hash] Dados da phase
+      def load_current_phase(state = nil)
+        state ||= @cache[:state] || load_state
+        phase_num = state&.dig('current_phase')
+        return nil unless phase_num
+
+        Gsd::Phase.find(phase_num, cwd: @cwd)
+      rescue => e
+        warn "[Context] Erro ao carregar phase: #{e.message}"
+        nil
+      end
+
+      # Carrega roadmap
+      #
+      # @return [Hash] Dados do roadmap
+      def load_roadmap
+        Gsd::Roadmap.analyze(cwd: @cwd)
+      rescue => e
+        warn "[Context] Erro ao carregar roadmap: #{e.message}"
+        {}
+      end
+
+      # Carrega todos
+      #
+      # @return [Array] Lista de todos
+      def load_todos
+        todos_path = File.join(@cwd, '.planning', 'todos')
+        return [] unless File.directory?(todos_path)
+
+        todos = []
+        Dir.glob(File.join(todos_path, '*.md')).each do |file|
+          content = File.read(file)
+          todos << {
+            file: File.basename(file),
+            content: content[0..500] # Primeiros 500 chars
+          }
+        end
+        todos
+      rescue => e
+        warn "[Context] Erro ao carregar todos: #{e.message}"
+        []
+      end
+
+      # Carrega commits recentes
+      #
+      # @return [Array] Lista de commits
+      def load_recent_commits
+        return [] unless git_available?
+
+        output = `git log -n 10 --oneline 2>/dev/null`
+        return [] if $?.exitstatus != 0
+
+        output.split("\n").map do |line|
+          parts = line.split(/\s+/, 2)
+          {
+            hash: parts[0],
+            message: parts[1]
+          }
+        end
+      rescue => e
+        warn "[Context] Erro ao carregar commits: #{e.message}"
+        []
+      end
+
+      # Carrega contexto do Git
+      #
+      # @return [Hash,nil] Dados do Git ou nil
+      def load_git_context
+        git = GitContext.new(cwd: @cwd)
+        git.gather
+      rescue => e
+        warn "[Context] Erro ao carregar git context: #{e.message}"
+        nil
+      end
+
+      # Verifica se git está disponível
+      #
+      # @return [Boolean] true se git está disponível
+      def git_available?
+        @git_available ||= File.directory?(File.join(@cwd, '.git'))
+      end
+
+      # Log de debug
+      #
+      # @param message [String] Mensagem de log
+      def log_debug(message)
+        return unless ENV['GSD_DEBUG']
+
+        puts "[Context] #{message}"
+      end
+    end
+  end
+end