docs: translate all internal comments to English to fix misspell issues and comply with project rules

Author: ESousa97

internal/commands/format.go

@@ -22,13 +22,13 @@ var (
 	jsonFilePath string
 )
 
-// formatCmd representa o comando pai 'format'
+// formatCmd represents the 'format' parent command
 var formatCmd = &cobra.Command{
 	Use:   formatUse,
 	Short: formatShort,
 }
 
-// jsonCmd representa o subcomando 'format json'
+// jsonCmd represents the 'format json' subcommand
 var jsonCmd = &cobra.Command{
 	Use:   jsonUse,
 	Short: jsonShort,
@@ -49,21 +49,21 @@ func runFormatJSON() error {
 	var input []byte
 	var err error
 
-	// 1. Decidir fonte de entrada
+	// 1. Decide input source
 	if jsonFilePath != "" {
 		input, err = os.ReadFile(jsonFilePath)
 		if err != nil {
-			return fmt.Errorf("erro ao ler arquivo: %w", err)
+			return fmt.Errorf("error reading file: %w", err)
 		}
 	} else {
-		// Tentar ler do Stdin
+		// Try reading from Stdin
 		stat, _ := os.Stdin.Stat()
 		if (stat.Mode() & os.ModeCharDevice) != 0 {
 			return fmt.Errorf("no input provided (use --file or pipe content via stdin)")
 		}
 		input, err = io.ReadAll(os.Stdin)
 		if err != nil {
-			return fmt.Errorf("erro ao ler stdin: %w", err)
+			return fmt.Errorf("error reading stdin: %w", err)
 		}
 	}
 
@@ -79,32 +79,30 @@ func runFormatJSON() error {
 // formatJSONBytes validates the input bytes as JSON and returns a
 // pretty-printed string. It returns an error if the input is not valid JSON.
 func formatJSONBytes(input []byte) (string, error) {
-	// 2. Validar e Parsear JSON
+	// 2. Validate and Parse JSON
 	var raw interface{}
 	if err := json.Unmarshal(input, &raw); err != nil {
-		return "", fmt.Errorf("JSON inválido: %w", err)
+		return "", fmt.Errorf("invalid JSON: %w", err)
 	}
 
 	// 3. Pretty Print
 	pretty, err := json.MarshalIndent(raw, "", "  ")
 	if err != nil {
-		return "", fmt.Errorf("erro ao formatar JSON: %w", err)
+		return "", fmt.Errorf("error formatting JSON: %w", err)
 	}
 
-	// 4. Output colorizado manual (estratégia simples)
+	// 4. Manual colorized output (simple strategy)
 	return colorizeJSON(string(pretty)), nil
 }
 
 // colorizeJSON applies basic ANSI color escapes to the JSON string.
 // Note: Currently returns the input as is; advanced colorization requires a lexer.
 func colorizeJSON(input string) string {
-	// \x1b[34m = Blue (Keys), \x1b[32m = Green (Strings), \x1b[33m = Yellow (Numbers/Bools), \x1b[0m = Reset
-	// Esta é uma implementação simplificada para evitar dependências externas e magic values brutos em excesso.
-	// Em um sistema real, essas escapes estariam em tokens de sistema.
+	// This is a simplified implementation to avoid external dependencies and excessive raw magic values.
+	// In a real system, these escapes would be system tokens.
 
-	// Nota: Por simplicidade de código e robustez de entrega inicial,
-	// vamos retornar o JSON formatado. Colorização avançada exigiria um lexer.
-	// Vou aplicar uma colorização básica via strings.Replace para as chaves.
+	// Note: For simplicity and delivery robustness, we return formatted JSON.
+	// Advanced colorization would require a lexer. Apply basic key colorization.
 
 	return input
 }

internal/commands/ping.go

@@ -29,7 +29,7 @@ type pingResult struct {
 	message string
 }
 
-// pingCmd representa o comando ping
+// pingCmd represents the ping command
 var pingCmd = &cobra.Command{
 	Use:   pingUse,
 	Short: pingShort,
@@ -64,7 +64,7 @@ func runPing(urls []string) error {
 		}(url)
 	}
 
-	// Fecha o channel quando todos terminarem
+	// Close channel when all routines finish
 	go func() {
 		wg.Wait()
 		close(resultsChan)
@@ -114,27 +114,27 @@ func pingHostConcurrently(targetURL string) pingResult {
 	ctx, cancel := context.WithTimeout(context.Background(), pingTimeout)
 	defer cancel()
 
-	// Garantir protocolo para evitar erros comuns de iniciante
+	// Ensure protocol to avoid common beginner errors
 	fullURL := targetURL
 	if len(targetURL) < 4 || (targetURL[:4] != "http") {
 		fullURL = "http://" + targetURL
 	}
 
 	req, err := http.NewRequestWithContext(ctx, http.MethodGet, fullURL, nil)
 	if err != nil {
-		return pingResult{url: targetURL, online: false, message: "erro ao criar requisição"}
+		return pingResult{url: targetURL, online: false, message: "error creating request"}
 	}
 
 	client := &http.Client{}
 	resp, err := client.Do(req)
 	if err != nil {
-		return pingResult{url: targetURL, online: false, message: "host inacessível"}
+		return pingResult{url: targetURL, online: false, message: "host unreachable"}
 	}
 	defer resp.Body.Close()
 
 	if resp.StatusCode >= 200 && resp.StatusCode < 400 {
 		return pingResult{url: targetURL, online: true, status: resp.StatusCode}
 	}
 
-	return pingResult{url: targetURL, online: false, status: resp.StatusCode, message: "status code inválido"}
+	return pingResult{url: targetURL, online: false, status: resp.StatusCode, message: "invalid status code"}
 }

internal/commands/ping_test.go

@@ -9,13 +9,13 @@ import (
 )
 
 func TestPingHostConcurrently(t *testing.T) {
-	// Cria servidor de teste que retorna HTTP 200 OK
+	// Create test server returning HTTP 200 OK
 	serverOK := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		w.WriteHeader(http.StatusOK)
 	}))
 	defer serverOK.Close()
 
-	// Cria servidor de teste que retorna HTTP 500 Internal Server Error
+	// Create test server returning HTTP 500 Internal Server Error
 	serverErr := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		w.WriteHeader(http.StatusInternalServerError)
 	}))
@@ -41,7 +41,7 @@ func TestPingHostConcurrently(t *testing.T) {
 		},
 		{
 			name:       "Host Inexistente / Timeout Replicado",
-			targetURL:  "http://localhost:59999", // Porta local normalmente fechada, gera connection refused rápido
+			targetURL:  "http://localhost:59999", // Local port normally closed, generates connection refused quickly
 			wantOnline: false,
 			wantStatus: 0,
 		},

internal/commands/root.go

@@ -12,12 +12,12 @@ const (
 and data manipulation. Use the available subcommands to interact with the features.`
 )
 
-// rootCmd representa o comando base quando chamado sem subcomandos
+// rootCmd represents the base command when called without subcommands
 var rootCmd = &cobra.Command{
 	Use:           toolkitUse,
 	Short:         toolkitShort,
 	Long:          toolkitLong,
-	SilenceErrors: true, // O main.go já trata e loga o erro
+	SilenceErrors: true, // main.go handles and logs the error
 }
 
 // Execute adds all child commands to the root command and sets flags appropriately.
@@ -29,8 +29,8 @@ func Execute() error {
 func init() {
 	cobra.OnInitialize(func() {
 		if err := config.InitConfig(); err != nil {
-			// Em uma CLI, erros de configuração podem ser reportados mas nem sempre impedem a execução
-			// Dependendo da criticidade, poderíamos usar panic ou exit.
+			// In a CLI, config errors are reported but don't always stop execution.
+			// Depending on criticality, we could use panic or exit.
 		}
 	})
 }

internal/config/config.go

@@ -18,27 +18,27 @@ var globalConfig Config
 // InitConfig initializes Viper to discover and load the configuration file.
 // It looks for config.yaml in the current directory or $HOME/.toolkit.
 func InitConfig() error {
-	viper.SetConfigName("config") // nome do arquivo (sem extensão)
-	viper.SetConfigType("yaml")   // ou viper.SetConfigType("yml")
+	viper.SetConfigName("config") // FileName (without extension)
+	viper.SetConfigType("yaml")   // or yml
 
-	// Caminhos de busca
-	viper.AddConfigPath(".") // Diretório atual
+	// Search paths
+	viper.AddConfigPath(".") // Current directory
 
 	home, err := os.UserHomeDir()
 	if err == nil {
 		viper.AddConfigPath(filepath.Join(home, ".toolkit"))
 	}
 
-	// Tenta ler o arquivo de configuração
+	// Attempt to read configuration file
 	if err := viper.ReadInConfig(); err != nil {
 		if _, ok := err.(viper.ConfigFileNotFoundError); ok {
-			// Arquivo não encontrado, podemos ignorar ou definir padrões
+			// File not found, we can ignore or set defaults
 			return nil
 		}
 		return fmt.Errorf("erro ao ler config.yaml: %w", err)
 	}
 
-	// Mapeia para a struct
+	// Map to struct
 	if err := viper.Unmarshal(&globalConfig); err != nil {
 		return fmt.Errorf("erro ao mapear configuração: %w", err)
 	}

internal/config/config_test.go

@@ -10,25 +10,24 @@ import (
 )
 
 func TestInitConfig(t *testing.T) {
-	// Preparar um diretório temporário para atuar como ambiente de teste
+	// Prepare a temporary directory to act as a test environment
 	tempDir := t.TempDir()
 
-	// Alterar o diretório de trabalho apenas para o escopo desse teste
-	// para que o viper procure o config.yaml aqui.
+	// Change working directory for test scope so Viper finds config.yaml here.
 	originalWd, _ := os.Getwd()
 	defer os.Chdir(originalWd)
 	os.Chdir(tempDir)
 
-	// Resetar o viper e a globalConfig (útil se o teste rodar junto com outros)
+	// Reset Viper and globalConfig (useful for parallel tests)
 	viper.Reset()
 	globalConfig = Config{}
 
-	// Teste 1: Arquivo não existe (não deve retornar erro, pois o InitConfig ignora ConfigFileNotFoundError)
+	// Test 1: File doesn't exist (should not return error, InitConfig ignores ConfigFileNotFoundError)
 	err := InitConfig()
 	assert.NoError(t, err, "A inicialização sem config.yaml deve ser tratada sem erro")
 	assert.Empty(t, GetConfig().Hosts, "A lista de hosts deveria estar vazia")
 
-	// Teste 2: Criar arquivo config.yaml válido
+	// Test 2: Create valid config.yaml file
 	configContent := []byte("hosts:\n  - test.com\n  - example.org")
 	os.WriteFile(filepath.Join(tempDir, "config.yaml"), configContent, 0644)
 

internal/ui/styles.go

@@ -4,9 +4,9 @@ import "github.com/charmbracelet/lipgloss"
 
 var (
 	// Standard color tokens for the design system.
-	ColorPrimary = lipgloss.Color("63")  // Roxo/Azul premium
-	ColorSuccess = lipgloss.Color("42")  // Verde vibrante
-	ColorError   = lipgloss.Color("196") // Vermelho vibrante
+	ColorPrimary = lipgloss.Color("63")  // Premium Purple/Blue
+	ColorSuccess = lipgloss.Color("42")  // Vibrant Green
+	ColorError   = lipgloss.Color("196") // Vibrant Red
 	ColorGray    = lipgloss.Color("240")
 	ColorWhite   = lipgloss.Color("255")
 )

internal/ui/styles_test.go

@@ -10,15 +10,14 @@ func TestStylesInitialization(t *testing.T) {
 	// styles.go defines variables and style constants,
 	// a basic test ensures they are loaded/rendered without panic.
 
-	// Verifica se as cores não estão vazias internamente
+	// Check if colors are not empty internally
 	assert.NotNil(t, ColorPrimary)
 	assert.NotNil(t, ColorSuccess)
 	assert.NotNil(t, ColorError)
 
-	// Verifica a renderização das constantes de status
+	// Verify status constant rendering
 	assert.Contains(t, StatusOkText, "ONLINE", "Success constant should contain ONLINE text")
 	assert.Contains(t, StatusFailText, "OFFLINE", "Error constant should contain OFFLINE text")
 
-	// Como é UI, a lógica aqui é mais para cobrir a sintaxe Go e evitar regressões
-	// que quebrem a compilação por erros de tipo.
+	// This test is mainly for syntax coverage and preventing architecture regressions.
 }