fantasy-cli 1.2.6

data/lib/gsd/ai/cost_tracker.rb

@@ -0,0 +1,361 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Gsd
+  module AI
+    # Cost Tracker - Rastreamento de custos e tokens em tempo real
+    #
+    # Responsável por:
+    # - Contagem precisa de tokens por provider
+    # - Cálculo de custos em tempo real
+    # - Budget tracking com alertas
+    # - Histórico de usage
+    # - Relatórios de custos
+    class CostTracker
+      attr_reader :total_cost, :total_tokens, :budget, :alerts_enabled
+
+      # Inicializa o cost tracker
+      #
+      # @param budget [Float] Orçamento mensal em USD
+      # @param alerts_enabled [Boolean] Habilitar alertas
+      # @param persist_dir [String] Diretório para persistência
+      def initialize(budget: 100.0, alerts_enabled: true, persist_dir: nil)
+        @budget = budget
+        @alerts_enabled = alerts_enabled
+        @persist_dir = persist_dir
+        @total_cost = 0.0
+        @total_tokens = 0
+        @usage_history = []
+        @alerts_triggered = []
+        @providers = {} # Pricing por provider
+
+        load_from_disk if @persist_dir
+        initialize_pricing
+      end
+
+      # Track uso de tokens e custo
+      #
+      # @param usage [Hash] Dados de uso (input_tokens, output_tokens)
+      # @param provider [String] Nome do provider
+      # @param model [String] Modelo usado
+      # @return [Hash] Custo e tokens trackeados
+      def track(usage, provider:, model:)
+        input_tokens = usage[:input_tokens] || usage['input_tokens'] || 0
+        output_tokens = usage[:output_tokens] || usage['output_tokens'] || 0
+        total_tokens = input_tokens + output_tokens
+
+        # Calcula custo
+        pricing = get_pricing(provider, model)
+        input_cost = (input_tokens.to_f / 1_000_000) * pricing[:input_price]
+        output_cost = (output_tokens.to_f / 1_000_000) * pricing[:output_price]
+        total_cost = input_cost + output_cost
+
+        # Atualiza totais
+        @total_tokens += total_tokens
+        @total_cost += total_cost
+
+        # Adiciona ao histórico
+        usage_record = {
+          timestamp: Time.now.iso8601,
+          provider: provider,
+          model: model,
+          input_tokens: input_tokens,
+          output_tokens: output_tokens,
+          total_tokens: total_tokens,
+          input_cost: input_cost,
+          output_cost: output_cost,
+          total_cost: total_cost
+        }
+        @usage_history << usage_record
+
+        # Verifica alertas
+        check_alerts if @alerts_enabled
+
+        # Persiste se configurado
+        save_to_disk if @persist_dir
+
+        usage_record
+      end
+
+      # Define orçamento
+      #
+      # @param budget [Float] Orçamento em USD
+      # @return [void]
+      def budget=(budget)
+        @budget = budget
+        check_alerts if @alerts_enabled
+      end
+
+      # Habilita/desabilita alertas
+      #
+      # @param enabled [Boolean] Habilitar alertas
+      # @return [void]
+      def alerts_enabled=(enabled)
+        @alerts_enabled = enabled
+      end
+
+      # Registra provider com pricing
+      #
+      # @param provider [String] Nome do provider
+      # @param models [Hash] Modelos com preços
+      # @return [void]
+      def register_provider(provider, models)
+        @providers[provider] = models
+      end
+
+      # Retorna estatísticas de uso
+      #
+      # @return [Hash] Estatísticas
+      def stats
+        {
+          total_cost: @total_cost,
+          total_tokens: @total_tokens,
+          budget: @budget,
+          budget_remaining: [@budget - @total_cost, 0].max,
+          budget_used_percent: (@total_cost / @budget * 100).round(2),
+          requests_count: @usage_history.count,
+          avg_cost_per_request: @usage_history.any? ? @total_cost / @usage_history.count : 0,
+          alerts_triggered_count: @alerts_triggered.count
+        }
+      end
+
+      # Retorna histórico de uso
+      #
+      # @param limit [Integer] Limite de registros
+      # @return [Array] Histórico
+      def history(limit: 100)
+        @usage_history.last(limit)
+      end
+
+      # Retorna alertas disparados
+      #
+      # @return [Array] Alertas
+      def alerts
+        @alerts_triggered
+      end
+
+      # Limpa histórico e totais
+      #
+      # @return [void]
+      def reset
+        @total_cost = 0.0
+        @total_tokens = 0
+        @usage_history = []
+        @alerts_triggered = []
+        save_to_disk if @persist_dir
+      end
+
+      # Exporta dados para JSON
+      #
+      # @return [String] JSON
+      def to_json
+        JSON.pretty_generate({
+          total_cost: @total_cost,
+          total_tokens: @total_tokens,
+          budget: @budget,
+          usage_history: @usage_history,
+          alerts_triggered: @alerts_triggered,
+          exported_at: Time.now.iso8601
+        })
+      end
+
+      # Importa dados de JSON
+      #
+      # @param json [String] JSON
+      # @return [void]
+      def from_json(json)
+        data = JSON.parse(json, symbolize_names: true)
+        @total_cost = data[:total_cost] || 0.0
+        @total_tokens = data[:total_tokens] || 0
+        @budget = data[:budget] || 100.0
+        @usage_history = data[:usage_history] || []
+        @alerts_triggered = data[:alerts_triggered] || []
+      end
+
+      private
+
+      # Inicializa pricing dos providers
+      #
+      # @return [void]
+      def initialize_pricing
+        # Anthropic
+        @providers['anthropic'] = {
+          'claude-sonnet-4-5-20250929' => { input_price: 3.0, output_price: 15.0 },
+          'claude-3-opus-20240229' => { input_price: 15.0, output_price: 75.0 },
+          'claude-3-haiku-20240307' => { input_price: 0.25, output_price: 1.25 }
+        }
+
+        # OpenAI
+        @providers['openai'] = {
+          'gpt-4-turbo-preview' => { input_price: 10.0, output_price: 30.0 },
+          'gpt-4-vision-preview' => { input_price: 10.0, output_price: 30.0 },
+          'gpt-4' => { input_price: 30.0, output_price: 60.0 },
+          'gpt-3.5-turbo' => { input_price: 0.5, output_price: 1.5 }
+        }
+
+        # OpenRouter (Qwen, Llama, Mistral - gratuitos)
+        @providers['openrouter'] = {
+          'qwen/qwen-3.6-plus-preview:free' => { input_price: 0.0, output_price: 0.0 },
+          'qwen/qwen-2.5-72b-instruct' => { input_price: 0.0, output_price: 0.0 },
+          'qwen/qwen-2-7b-instruct' => { input_price: 0.0, output_price: 0.0 },
+          'meta-llama/llama-3-8b-instruct' => { input_price: 0.0, output_price: 0.0 },
+          'meta-llama/llama-3-70b-instruct' => { input_price: 0.0, output_price: 0.0 },
+          'mistralai/mistral-7b-instruct' => { input_price: 0.0, output_price: 0.0 },
+          'google/gemma-7b-it' => { input_price: 0.0, output_price: 0.0 }
+        }
+
+        # Ollama (local, gratuito)
+        @providers['ollama'] = {
+          '*' => { input_price: 0.0, output_price: 0.0 }
+        }
+
+        # LM Studio (local, gratuito)
+        @providers['lmstudio'] = {
+          '*' => { input_price: 0.0, output_price: 0.0 }
+        }
+      end
+
+      # Obtém pricing para provider/modelo
+      #
+      # @param provider [String] Nome do provider
+      # @param model [String] Modelo
+      # @return [Hash] Pricing
+      def get_pricing(provider, model)
+        provider_models = @providers[provider&.downcase]
+        return { input_price: 0, output_price: 0 } unless provider_models
+
+        # Tenta encontrar modelo exato
+        pricing = provider_models[model] || provider_models[model&.downcase]
+
+        # Fallback para wildcard
+        pricing ||= provider_models['*']
+
+        # Default gratuito
+        pricing || { input_price: 0, output_price: 0 }
+      end
+
+      # Verifica e dispara alertas
+      #
+      # @return [void]
+      def check_alerts
+        usage_percent = (@total_cost / @budget * 100)
+
+        # Alertas em 50%, 75%, 90%, 100%
+        thresholds = [50, 75, 90, 100]
+
+        thresholds.each do |threshold|
+          alert_key = "budget_#{threshold}"
+
+          # Verifica se já disparou este alerta
+          next if @alerts_triggered.any? { |a| a[:key] == alert_key }
+
+          if usage_percent >= threshold
+            alert = {
+              key: alert_key,
+              threshold: threshold,
+              usage_percent: usage_percent.round(2),
+              total_cost: @total_cost,
+              budget: @budget,
+              timestamp: Time.now.iso8601,
+              message: "Orçamento: #{usage_percent.round(1)}% utilizado ($#{@total_cost.round(2)} de $#{@budget})"
+            }
+
+            @alerts_triggered << alert
+            trigger_alert(alert)
+          end
+        end
+      end
+
+      # Dispara alerta
+      #
+      # @param alert [Hash] Dados do alerta
+      # @return [void]
+      def trigger_alert(alert)
+        puts "\n⚠️  ALERTA DE CUSTO: #{alert[:message]}"
+
+        # Aqui poderia integrar com webhook, email, etc.
+        # Exemplo: enviar para Discord, Slack, etc.
+      end
+
+      # Salva dados em disco
+      #
+      # @return [void]
+      def save_to_disk
+        return unless @persist_dir
+
+        FileUtils.mkdir_p(@persist_dir)
+        file = File.join(@persist_dir, 'cost_tracker.json')
+        File.write(file, to_json)
+      end
+
+      # Carrega dados do disco
+      #
+      # @return [void]
+      def load_from_disk
+        return unless @persist_dir
+
+        file = File.join(@persist_dir, 'cost_tracker.json')
+        return unless File.exist?(file)
+
+        json = File.read(file)
+        from_json(json)
+      rescue => e
+        warn "[CostTracker] Erro ao carregar: #{e.message}"
+      end
+    end
+
+    # Budget Manager - Gerenciamento avançado de orçamento
+    class BudgetManager
+      attr_reader :trackers
+
+      # Inicializa o budget manager
+      #
+      # @param global_budget [Float] Orçamento global
+      def initialize(global_budget: 500.0)
+        @global_budget = global_budget
+        @trackers = {} # Trackers por projeto/contexto
+        @allocations = {} # Alocações por projeto
+      end
+
+      # Cria tracker para projeto
+      #
+      # @param project [String] Nome do projeto
+      # @param budget [Float] Orçamento do projeto
+      # @return [CostTracker] Tracker criado
+      def create_tracker(project, budget: nil)
+        project_budget = budget || @allocations[project] || (@global_budget * 0.2) # 20% default
+
+        tracker = CostTracker.new(budget: project_budget)
+        @trackers[project] = tracker
+        tracker
+      end
+
+      # Aloca orçamento para projeto
+      #
+      # @param project [String] Nome do projeto
+      # @param amount [Float] Valor alocado
+      # @return [void]
+      def allocate(project, amount)
+        @allocations[project] = amount
+        @trackers[project]&.budget = amount if @trackers[project]
+      end
+
+      # Retorna visão geral de todos projetos
+      #
+      # @return [Hash] Visão geral
+      def overview
+        total_allocated = @allocations.values.sum
+        total_spent = @trackers.values.sum(&:total_cost)
+
+        {
+          global_budget: @global_budget,
+          total_allocated: total_allocated,
+          total_spent: total_spent,
+          remaining: @global_budget - total_spent,
+          projects: @trackers.transform_values(&:stats)
+        }
+      end
+    end
+  end
+end

data/lib/gsd/ai/git_context.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module Gsd
+  module AI
+    # GitContext - Coleta informações de status do Git
+    #
+    # Responsável por:
+    # - Branch atual
+    # - Status (clean/dirty)
+    # - Files modificados
+    # - Ahead/behind do remote
+    class GitContext
+      attr_reader :cwd
+
+      # Inicializa o GitContext
+      #
+      # @param cwd [String] Diretório de trabalho
+      def initialize(cwd: Dir.pwd)
+        @cwd = cwd
+      end
+
+      # Coleta informações do Git
+      #
+      # @return [Hash] Informações do Git
+      def gather
+        return nil unless git_available?
+
+        {
+          branch: current_branch,
+          clean: clean?,
+          modified_files: modified_files,
+          staged_files: staged_files,
+          untracked_files: untracked_files,
+          ahead_behind: ahead_behind,
+          last_commit: last_commit
+        }
+      end
+
+      # Branch atual
+      #
+      # @return [String,nil] Nome da branch ou nil
+      def current_branch
+        return nil unless git_available?
+
+        branch = git_command('rev-parse --abbrev-ref HEAD')
+        branch&.strip
+      end
+
+      # Verifica se o working tree está limpo
+      #
+      # @return [Boolean] true se limpo
+      def clean?
+        return true unless git_available?
+
+        status = git_command('status --porcelain')
+        status.nil? || status.strip.empty?
+      end
+
+      # Lista files modificados
+      #
+      # @return [Array<String>] Lista de files
+      def modified_files
+        return [] unless git_available?
+
+        status = git_command('status --porcelain')
+        return [] if status.nil?
+
+        status.lines
+              .select { |l| l.start_with?(' M', 'M ') }
+              .map { |l| l[3..]&.strip }
+              .compact
+      end
+
+      # Lista files staged
+      #
+      # @return [Array<String>] Lista de files
+      def staged_files
+        return [] unless git_available?
+
+        status = git_command('status --porcelain')
+        return [] if status.nil?
+
+        status.lines
+              .select { |l| l.start_with?('A ', 'M ') }
+              .map { |l| l[3..]&.strip }
+              .compact
+      end
+
+      # Lista files não rastreados
+      #
+      # @return [Array<String>] Lista de files
+      def untracked_files
+        return [] unless git_available?
+
+        status = git_command('status --porcelain')
+        return [] if status.nil?
+
+        status.lines
+              .select { |l| l.start_with?('??') }
+              .map { |l| l[3..]&.strip }
+              .compact
+      end
+
+      # Ahead/behind do remote
+      #
+      # @return [Hash] {ahead: int, behind: int}
+      def ahead_behind
+        return { ahead: 0, behind: 0 } unless git_available?
+
+        # Verifica se tem upstream configurado
+        upstream = git_command('rev-parse --abbrev-ref --symbolic-full-name @{upstream} 2>nul')
+        return { ahead: 0, behind: 0 } if upstream.nil? || upstream.strip.empty?
+
+        # Conta commits ahead/behind
+        counts = git_command('rev-list --left-right --count HEAD...@{upstream} 2>nul')
+        return { ahead: 0, behind: 0 } if counts.nil?
+
+        ahead, behind = counts.strip.split.map(&:to_i)
+        { ahead: ahead || 0, behind: behind || 0 }
+      rescue
+        { ahead: 0, behind: 0 }
+      end
+
+      # Último commit
+      #
+      # @return [Hash,nil] Informações do último commit
+      def last_commit
+        return nil unless git_available?
+
+        hash = git_command('rev-parse --short HEAD')
+        return nil if hash.nil?
+
+        message = git_command('log -1 --pretty=%s')
+        author = git_command('log -1 --pretty=%an')
+        date = git_command('log -1 --pretty=%ar')
+
+        {
+          hash: hash&.strip,
+          message: message&.strip,
+          author: author&.strip,
+          date: date&.strip
+        }
+      end
+
+      private
+
+      # Verifica se Git está disponível
+      #
+      # @return [Boolean] true se disponível
+      def git_available?
+        return @git_available if defined?(@git_available)
+
+        @git_available = File.directory?(File.join(@cwd, '.git'))
+      end
+
+      # Executa comando git
+      #
+      # @param args [String] Argumentos do comando
+      # @return [String,nil] Output ou nil se falhar
+      def git_command(args)
+        cmd = "git -C #{@cwd} #{args} 2>nul"
+        output = `#{cmd}`
+        $?.exitstatus == 0 ? output : nil
+      rescue
+        nil
+      end
+    end
+  end
+end