Implementación de Smart Routing, Control de Costos y Gestión de Caché

cmd/main.go

@@ -6,12 +6,14 @@ import (
 	"log"
 	"os"
 
+	"github.com/Tomas-vilte/MateCommit/internal/cli/command/cache"
 	"github.com/Tomas-vilte/MateCommit/internal/cli/command/completion"
 	"github.com/Tomas-vilte/MateCommit/internal/cli/command/config"
 	"github.com/Tomas-vilte/MateCommit/internal/cli/command/handler"
 	"github.com/Tomas-vilte/MateCommit/internal/cli/command/issues"
 	"github.com/Tomas-vilte/MateCommit/internal/cli/command/pull_requests"
 	"github.com/Tomas-vilte/MateCommit/internal/cli/command/release"
+	"github.com/Tomas-vilte/MateCommit/internal/cli/command/stats"
 	"github.com/Tomas-vilte/MateCommit/internal/cli/command/suggests_commits"
 	"github.com/Tomas-vilte/MateCommit/internal/cli/command/update"
 	"github.com/Tomas-vilte/MateCommit/internal/cli/registry"
@@ -133,6 +135,8 @@ func initializeApp() (*cli.Command, error) {
 
 	commands := registerCommand.CreateCommands()
 	commands = append(commands, completion.NewCompletionCommand(translations))
+	commands = append(commands, stats.NewStatsCommand().CreateCommand(translations, cfgApp))
+	commands = append(commands, cache.NewCacheCommand().CreateCommand(translations, cfgApp))
 
 	helpCommand := &cli.Command{
 		Name:    "help",

internal/cli/command/cache/cache.go

@@ -0,0 +1,46 @@
+package cache
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/Tomas-vilte/MateCommit/internal/config"
+	"github.com/Tomas-vilte/MateCommit/internal/i18n"
+	"github.com/Tomas-vilte/MateCommit/internal/infrastructure/cache"
+	"github.com/fatih/color"
+	"github.com/urfave/cli/v3"
+)
+
+type CacheCommand struct{}
+
+func NewCacheCommand() *CacheCommand {
+	return &CacheCommand{}
+}
+
+func (c *CacheCommand) CreateCommand(t *i18n.Translations, _ *config.Config) *cli.Command {
+	return &cli.Command{
+		Name:  "cache",
+		Usage: t.GetMessage("cache.usage", 0, nil),
+		Commands: []*cli.Command{
+			{
+				Name:  "clean",
+				Usage: t.GetMessage("cache.clean_usage", 0, nil),
+				Action: func(ctx context.Context, cmd *cli.Command) error {
+					cacheService, err := cache.NewCache(24 * time.Hour)
+					if err != nil {
+						return fmt.Errorf(t.GetMessage("cache.error_init", 0, nil)+": %w", err)
+					}
+
+					if err := cacheService.Clean(); err != nil {
+						return fmt.Errorf(t.GetMessage("cache.error_clean", 0, nil)+": %w", err)
+					}
+
+					green := color.New(color.FgGreen, color.Bold)
+					_, _ = green.Printf("✓ %s\n", t.GetMessage("cache.cleaned", 0, nil))
+					return nil
+				},
+			},
+		},
+	}
+}

internal/cli/command/config/init.go

@@ -158,7 +158,7 @@ func configureWelcome(ctx context.Context, reader *bufio.Reader, cfg *config.Con
 
 	cfg.AIProviders["gemini"] = config.AIProviderConfig{
 		APIKey:      apiKey,
-		Model:       selectedModel,
+		Model:       string(config.ModelGeminiV15Flash),
 		Temperature: 0.3,
 		MaxTokens:   10000,
 	}
@@ -366,7 +366,7 @@ func validateGeminiAPIKey(ctx context.Context, apiKey string, t *i18n.Translatio
 		AIProviders: map[string]config.AIProviderConfig{
 			"gemini": {
 				APIKey:      apiKey,
-				Model:       string(config.ModelGeminiV25Flash),
+				Model:       string(config.ModelGeminiV15Flash),
 				Temperature: 0.3,
 				MaxTokens:   10000,
 			},

internal/cli/command/config/init_test.go

@@ -62,7 +62,6 @@ func runInitCommandTest(t *testing.T, userInput string, fullMode bool) (output s
 	factory := &ConfigCommandFactory{}
 	cmd := factory.newInitCommand(translations, cfg)
 
-	// Create app with the command to properly handle flags
 	app := &cli.Command{
 		Name:     "test",
 		Commands: []*cli.Command{cmd},
@@ -92,7 +91,7 @@ func TestInitCommand(t *testing.T) {
 			"my-gemini-api-key", "gemini-1.5-flash", "en", "yes", "my-github-token", "yes",
 			"https://myjira.atlassian.net", "[email protected]", "my-jira-token", "no",
 		}, "\n") + "\n"
-		output, finalCfg := runInitCommandTest(t, userInput, true) // Use full mode
+		output, finalCfg := runInitCommandTest(t, userInput, true)
 		assert.Contains(t, output, "Introduce tu API Key de")
 		assert.Contains(t, output, "Introduce tu token de acceso de GitHub")
 		assert.Contains(t, output, "URL base de tu instancia de Jira")
@@ -108,15 +107,15 @@ func TestInitCommand(t *testing.T) {
 		userInput := strings.Join([]string{
 			"test-api-key", "", "", "no", "n", "no",
 		}, "\n") + "\n"
-		output, finalCfg := runInitCommandTest(t, userInput, true) // Use full mode
+		output, finalCfg := runInitCommandTest(t, userInput, true)
 
 		assert.Contains(t, output, "Servicio de tickets deshabilitado")
 		assert.NotContains(t, output, "Introduce tu token de acceso de GitHub")
 
 		if finalCfg.AIProviders != nil && finalCfg.AIProviders["gemini"].APIKey != "" {
 			assert.Equal(t, "test-api-key", finalCfg.AIProviders["gemini"].APIKey)
 		}
-		assert.Equal(t, config.Model("gemini-2.5-pro"), finalCfg.AIConfig.Models[config.AIGemini])
+		assert.Equal(t, config.ModelGeminiV15Flash, finalCfg.AIConfig.Models[config.AIGemini])
 		assert.Equal(t, "", finalCfg.ActiveVCSProvider)
 		assert.False(t, finalCfg.UseTicket)
 	})
@@ -125,7 +124,7 @@ func TestInitCommand(t *testing.T) {
 		userInput := strings.Join([]string{
 			"", "", "fr", "no", "no", "no",
 		}, "\n") + "\n"
-		output, finalCfg := runInitCommandTest(t, userInput, true) // Use full mode
+		output, finalCfg := runInitCommandTest(t, userInput, true)
 		assert.Contains(t, output, "Idioma inválido. Por favor ingresa 'en' o 'es'.")
 		assert.Equal(t, "es", finalCfg.Language)
 	})
@@ -135,7 +134,7 @@ func TestInitCommand(t *testing.T) {
 			"first-run-key", "", "es", "no", "no", "yes",
 			"second-run-key", "gemini-pro", "en", "no", "no", "no",
 		}, "\n") + "\n"
-		output, finalCfg := runInitCommandTest(t, userInput, true) // Use full mode
+		output, finalCfg := runInitCommandTest(t, userInput, true)
 
 		assert.Equal(t, 2, strings.Count(output, "Introduce tu API Key de"))
 		assert.Equal(t, 2, strings.Count(output, "Resumen de configuración"))

internal/cli/command/config/show_test.go

@@ -76,7 +76,7 @@ func TestShowCommand(t *testing.T) {
 		cfg.AIConfig = config.AIConfig{
 			ActiveAI: config.AIGemini,
 			Models: map[config.AI]config.Model{
-				config.AIGemini: config.ModelGeminiV25Flash,
+				config.AIGemini: config.ModelGeminiV15Flash,
 				config.AIOpenAI: config.ModelGPTV4o,
 			},
 		}
@@ -111,8 +111,7 @@ func TestShowCommand(t *testing.T) {
 		assert.Contains(t, output, "Servicio de tickets habilitado: jira")
 		assert.Contains(t, output, "Configuración de Jira - BaseURL: https://example.atlassian.net, Email: [email protected]")
 
-		// Check AI models
-		assert.Contains(t, output, "gemini: gemini-2.5-flash")
+		assert.Contains(t, output, "gemini: gemini-1.5-flash")
 		assert.Contains(t, output, "openai: gpt-4o")
 	})
 }

internal/cli/command/stats/stats.go

@@ -0,0 +1,130 @@
+package stats
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/Tomas-vilte/MateCommit/internal/config"
+	"github.com/Tomas-vilte/MateCommit/internal/i18n"
+	"github.com/Tomas-vilte/MateCommit/internal/services/cost"
+	"github.com/fatih/color"
+	"github.com/urfave/cli/v3"
+)
+
+type StatsCommand struct{}
+
+func NewStatsCommand() *StatsCommand {
+	return &StatsCommand{}
+}
+
+func (c *StatsCommand) CreateCommand(t *i18n.Translations, _ *config.Config) *cli.Command {
+	return &cli.Command{
+		Name:    "stats",
+		Aliases: []string{"cost"},
+		Usage:   t.GetMessage("stats.usage", 0, nil),
+		Flags: []cli.Flag{
+			&cli.BoolFlag{
+				Name:    "monthly",
+				Aliases: []string{"m"},
+				Usage:   t.GetMessage("stats.monthly_flag", 0, nil),
+			},
+		},
+		Action: func(ctx context.Context, cmd *cli.Command) error {
+			manager, err := cost.NewManager(0, t)
+			if err != nil {
+				return fmt.Errorf(t.GetMessage("stats.error_init", 0, nil)+": %w", err)
+			}
+
+			showMonthly := cmd.Bool("monthly")
+
+			if showMonthly {
+				return c.showMonthlyStats(manager, t)
+			}
+			return c.showDailyStats(manager, t)
+		},
+	}
+}
+
+func (c *StatsCommand) showDailyStats(manager *cost.Manager, t *i18n.Translations) error {
+	total, err := manager.GetDailyTotal()
+	if err != nil {
+		return err
+	}
+	records, err := manager.GetHistory()
+	if err != nil {
+		return err
+	}
+	today := time.Now().Format("2006-01-02")
+	var todayRecords []cost.ActivityRecord
+	for _, r := range records {
+		if r.Timestamp.Format("2006-01-02") == today {
+			todayRecords = append(todayRecords, r)
+		}
+	}
+	cyan := color.New(color.FgCyan, color.Bold)
+	green := color.New(color.FgGreen)
+	yellow := color.New(color.FgYellow)
+	_, _ = cyan.Printf("\n📊 %s\n", t.GetMessage("stats.daily_title", 0, nil))
+	fmt.Println("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
+	if len(todayRecords) == 0 {
+		fmt.Printf("\n%s\n\n", t.GetMessage("stats.no_activity", 0, nil))
+		return nil
+	}
+	for _, record := range todayRecords {
+		cacheIndicator := ""
+		if record.CacheHit {
+			cacheIndicator = green.Sprint(" [CACHE]")
+		}
+		fmt.Printf("%s - %s: %s%s\n",
+			record.Timestamp.Format("15:04"),
+			record.Command,
+			yellow.Sprintf("$%.4f", record.CostUSD),
+			cacheIndicator,
+		)
+	}
+	fmt.Println("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
+	_, _ = cyan.Printf("%s: ", t.GetMessage("stats.total_today", 0, nil))
+	_, _ = yellow.Printf("$%.4f USD\n\n", total)
+	return nil
+}
+
+func (c *StatsCommand) showMonthlyStats(manager *cost.Manager, t *i18n.Translations) error {
+	total, err := manager.GetMonthlyTotal()
+	if err != nil {
+		return err
+	}
+	records, err := manager.GetHistory()
+	if err != nil {
+		return err
+	}
+	currentMonth := time.Now().Format("2006-01")
+	var monthRecords []cost.ActivityRecord
+	for _, r := range records {
+		if r.Timestamp.Format("2006-01") == currentMonth {
+			monthRecords = append(monthRecords, r)
+		}
+	}
+	cyan := color.New(color.FgCyan, color.Bold)
+	yellow := color.New(color.FgYellow)
+	_, _ = cyan.Printf("\n📅 %s\n", t.GetMessage("stats.monthly_title", 0, map[string]interface{}{
+		"Month": time.Now().Format("January 2006"),
+	}))
+	fmt.Println("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
+	if len(monthRecords) == 0 {
+		fmt.Printf("\n%s\n\n", t.GetMessage("stats.no_activity", 0, nil))
+		return nil
+	}
+	dailyTotals := make(map[string]float64)
+	for _, record := range monthRecords {
+		day := record.Timestamp.Format("2006-01-02")
+		dailyTotals[day] += record.CostUSD
+	}
+	for day, dayTotal := range dailyTotals {
+		fmt.Printf("%s: %s\n", day, yellow.Sprintf("$%.4f", dayTotal))
+	}
+	fmt.Println("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
+	_, _ = cyan.Printf("%s: ", t.GetMessage("stats.total_month", 0, nil))
+	_, _ = yellow.Printf("$%.4f USD\n\n", total)
+	return nil
+}