@archznn/xavva 3.1.3 → 3.2.0

package/src/commands/DoctorCommand.ts

@@ -1,233 +1,246 @@
 import type { Command } from "./Command";
 import type { AppConfig, CLIArguments } from "../types/config";
-import { Logger } from "../utils/ui";
+import { Logger } from "../logging";
 import fs from "fs";
 import path from "path";
 import os from "os";
 import {
-	getCatalinaScript,
-	getWhichCommand,
-	getJbrDownloadUrl,
-	getTarExtractCommand,
-	getJavaPath,
-	getJavaBinary,
-	isWindows,
-	isLinux,
-	isMacOS,
+    getCatalinaScript,
+    getWhichCommand,
+    getJbrDownloadUrl,
+    getTarExtractCommand,
+    getJavaPath,
+    getJavaBinary,
+    isWindows,
+    isLinux,
+    isMacOS,
 } from "../utils/platform";
 
 export class DoctorCommand implements Command {
-	async execute(config: AppConfig, values: CLIArguments = {}): Promise<void> {
-		Logger.section("Xavva Doctor - Ambiente");
-
-		this.check(
-			"JAVA_HOME",
-			!!process.env.JAVA_HOME,
-			process.env.JAVA_HOME || "Não definido",
-		);
-
-		const jvmInfo = this.checkJVM();
-		this.check(
-			"JVM Type",
-			jvmInfo.dcevm,
-			jvmInfo.name +
-			(jvmInfo.dcevm ? " (Advanced Hot Reload OK)" : " (Standard)"),
-		);
-
-		if (!jvmInfo.dcevm) {
-			Logger.log(
-				`    ${Logger.C.warning}💡 Dica: Sua JVM não suporta mudanças estruturais (novos métodos/campos).${Logger.C.reset}`,
-			);
-			if (values.fix) {
-				await this.installDCEVM();
-			} else {
-				Logger.log(
-					`    ${Logger.C.primary}Use 'xavva doctor --fix' para baixar uma JDK com DCEVM integrado.${Logger.C.reset}`,
-				);
-			}
-		}
-
-		const tomcatOk = fs.existsSync(config.tomcat.path);
-		this.check("Tomcat Path", tomcatOk, config.tomcat.path);
-
-		if (tomcatOk) {
-			const binOk = fs.existsSync(
-				path.join(config.tomcat.path, "bin", getCatalinaScript()),
-			);
-			this.check(
-				"Tomcat Bin",
-				binOk,
-				binOk ? "OK" : `${getCatalinaScript()} não encontrado`,
-			);
-		}
-
-		const mvnOk = this.checkBinary("mvn");
-		this.check("Maven", mvnOk, mvnOk ? "Disponível" : "Não encontrado no PATH");
-
-		const gradleOk = this.checkBinary("gradle") || this.checkBinary("gradlew");
-		this.check(
-			"Gradle",
-			gradleOk,
-			gradleOk ? "Disponível" : "Não encontrado no PATH",
-		);
-
-		const gitOk = this.checkBinary("git");
-		this.check("Git", gitOk, gitOk ? "Disponível" : "Não encontrado no PATH");
-
-		Logger.section("Xavva Doctor - Integridade de Arquivos");
-		await this.checkJarIntegrity(values.fix, config);
-		await this.checkBOM(values.fix);
-
-		console.log("");
-	}
-
-	private async checkJarIntegrity(fix: boolean, config: AppConfig) {
-		const searchPaths = [
-			path.join(process.cwd(), "target"),
-			path.join(process.cwd(), "build"),
-			path.join(config.tomcat.path, "webapps")
-		].filter(p => fs.existsSync(p));
-
-		const corruptedJars: string[] = [];
-		const zipEndSignature = Buffer.from([0x50, 0x4b, 0x05, 0x06]);
-
-		const scan = (dir: string) => {
-			try {
-				const list = fs.readdirSync(dir, { withFileTypes: true });
-				for (const item of list) {
-					const res = path.resolve(dir, item.name);
-					if (item.isDirectory()) {
-						if (item.name === "node_modules" || item.name === ".git") continue;
-						scan(res);
-					} else if (item.name.endsWith(".jar")) {
-						try {
-							const stats = fs.statSync(res);
-							if (stats.size < 22) {
-								corruptedJars.push(res);
-								continue;
-							}
-
-							// Lê os últimos 1024 bytes para encontrar a assinatura EOCD do ZIP
-							const readSize = Math.min(stats.size, 1024);
-							const buffer = Buffer.alloc(readSize);
-							const fd = fs.openSync(res, "r");
-							fs.readSync(fd, buffer, 0, readSize, stats.size - readSize);
-							fs.closeSync(fd);
-
-							if (!buffer.includes(zipEndSignature)) {
-								corruptedJars.push(res);
-							}
-						} catch (e) {
-							corruptedJars.push(res);
-						}
-					}
-				}
-			} catch (e) {}
-		};
-
-		for (const p of searchPaths) {
-			scan(p);
-		}
-
-		if (corruptedJars.length > 0) {
-			this.check(
-				"Integridade JAR",
-				false,
-				`${corruptedJars.length} arquivos corrompidos detectados.`,
-			);
-			if (fix) {
-				for (const file of corruptedJars) {
-					try {
-						fs.unlinkSync(file);
-						console.log(`    \x1b[32m✔\x1b[0m Removido: ${path.basename(file)}`);
-					} catch (e) {}
-				}
-				Logger.success("JARs corrompidos removidos! Eles serão reconstruídos no próximo build.");
-				
-				// Limpar cache do Tomcat
-				Logger.process("Limpando cache do Tomcat (work/temp)...");
-				const tomcatWork = path.join(config.tomcat.path, "work");
-				const tomcatTemp = path.join(config.tomcat.path, "temp");
-				[tomcatWork, tomcatTemp].forEach(p => {
-					try {
-						if (fs.existsSync(p)) {
-							fs.rmSync(p, { recursive: true, force: true });
-							fs.mkdirSync(p);
-						}
-					} catch (e) {}
-				});
-				Logger.success("Cache do Tomcat limpo com sucesso.");
-			} else {
-				Logger.warn(
-					"Use 'xavva doctor --fix' para remover os JARs corrompidos e limpar o cache.",
-				);
-			}
-		} else {
-			this.check("Integridade JAR", true, "Todos os arquivos JAR parecem íntegros.");
-		}
-	}
-
-	private async checkBOM(fix: boolean) {
-		const srcPath = path.join(process.cwd(), "src");
-		if (!fs.existsSync(srcPath)) return;
-
-		const filesWithBOM: string[] = [];
-		const scan = (dir: string) => {
-			const list = fs.readdirSync(dir, { withFileTypes: true });
-			for (const item of list) {
-				const res = path.resolve(dir, item.name);
-				if (item.isDirectory()) {
-					scan(res);
-				} else if (item.name.endsWith(".java")) {
-					const buffer = fs.readFileSync(res);
-					if (buffer[0] === 0xef && buffer[1] === 0xbb && buffer[2] === 0xbf) {
-						filesWithBOM.push(res);
-					}
-				}
-			}
-		};
-
-		scan(srcPath);
-
-		if (filesWithBOM.length > 0) {
-			this.check(
-				"Encoding BOM",
-				false,
-				`${filesWithBOM.length} arquivos com BOM (UTF-8 com assinatura)`,
-			);
-			if (fix) {
-				for (const file of filesWithBOM) {
-					const buffer = fs.readFileSync(file);
-					const cleanBuffer = buffer.subarray(3);
-					fs.writeFileSync(file, cleanBuffer);
-					console.log(
-						`    \x1b[32m✔\x1b[0m Corrigido: ${path.basename(file)}`,
-					);
-				}
-				Logger.success("BOM removido de todos os arquivos!");
-			} else {
-				Logger.warn(
-					"Use 'xavva doctor --fix' para remover o BOM automaticamente.",
-				);
-			}
-		} else {
-			this.check("Encoding BOM", true, "Nenhum arquivo com BOM detectado.");
-		}
-	}
-
-	private check(label: string, ok: boolean, detail: string) {
-		const icon = ok ? "\x1b[32m✔\x1b[0m" : "\x1b[31m✘\x1b[0m";
-		console.log(`  ${icon} ${label.padEnd(15)} ${detail}`);
-	}
-
-	private checkBinary(name: string): boolean {
-		try {
-			const proc = Bun.spawnSync(getWhichCommand(name));
-			return proc.exitCode === 0;
-		} catch {
-			return false;
-		}
-	}
+    private logger = Logger.getInstance();
+
+    async execute(config: AppConfig, values: CLIArguments = {}): Promise<void> {
+        this.logger.section("Xavva Doctor - Diagnóstico");
+        
+        // Se modo fix, mostra aviso
+        if (values.fix) {
+            this.logger.warn("Modo --fix ativado - Problemas serão corrigidos automaticamente");
+            this.logger.newline();
+        }
+
+        const issues: Array<{ label: string; ok: boolean; detail: string; fixable?: boolean }> = [];
+
+        // Verifica JAVA_HOME
+        const javaHomeOk = !!process.env.JAVA_HOME;
+        issues.push({
+            label: "JAVA_HOME",
+            ok: javaHomeOk,
+            detail: process.env.JAVA_HOME || "Não definido",
+            fixable: true,
+        });
+
+        const jvmInfo = this.checkJVM();
+        this.check(
+            "JVM Type",
+            jvmInfo.dcevm,
+            jvmInfo.name +
+            (jvmInfo.dcevm ? " (Advanced Hot Reload OK)" : " (Standard)"),
+        );
+
+        if (!jvmInfo.dcevm) {
+            console.log(
+                `    💡 Dica: Sua JVM não suporta mudanças estruturais (novos métodos/campos).`,
+            );
+            if (values.fix) {
+                await this.installDCEVM();
+            } else {
+                console.log(
+                    `    Use 'xavva doctor --fix' para baixar uma JDK com DCEVM integrado.`,
+                );
+            }
+        }
+
+        const tomcatOk = fs.existsSync(config.tomcat.path);
+        this.check("Tomcat Path", tomcatOk, config.tomcat.path);
+
+        if (tomcatOk) {
+            const binOk = fs.existsSync(
+                path.join(config.tomcat.path, "bin", getCatalinaScript()),
+            );
+            this.check(
+                "Tomcat Bin",
+                binOk,
+                binOk ? "OK" : `${getCatalinaScript()} não encontrado`,
+            );
+        }
+
+        const mvnOk = this.checkBinary("mvn");
+        this.check("Maven", mvnOk, mvnOk ? "Disponível" : "Não encontrado no PATH");
+
+        const gradleOk = this.checkBinary("gradle") || this.checkBinary("gradlew");
+        this.check(
+            "Gradle",
+            gradleOk,
+            gradleOk ? "Disponível" : "Não encontrado no PATH",
+        );
+
+        const gitOk = this.checkBinary("git");
+        this.check("Git", gitOk, gitOk ? "Disponível" : "Não encontrado no PATH");
+
+        this.logger.section("Xavva Doctor - Integridade de Arquivos");
+        await this.checkJarIntegrity(values.fix, config);
+        await this.checkBOM(values.fix);
+
+        console.log("");
+    }
+
+    private async checkJarIntegrity(fix: boolean, config: AppConfig) {
+        const searchPaths = [
+            path.join(process.cwd(), "target"),
+            path.join(process.cwd(), "build"),
+            path.join(config.tomcat.path, "webapps")
+        ].filter(p => fs.existsSync(p));
+
+        const corruptedJars: string[] = [];
+        const zipEndSignature = Buffer.from([0x50, 0x4b, 0x05, 0x06]);
+
+        const scan = (dir: string) => {
+            try {
+                const list = fs.readdirSync(dir, { withFileTypes: true });
+                for (const item of list) {
+                    const res = path.resolve(dir, item.name);
+                    if (item.isDirectory()) {
+                        if (item.name === "node_modules" || item.name === ".git") continue;
+                        scan(res);
+                    } else if (item.name.endsWith(".jar")) {
+                        try {
+                            const stats = fs.statSync(res);
+                            if (stats.size < 22) {
+                                corruptedJars.push(res);
+                                continue;
+                            }
+
+                            // Lê os últimos 1024 bytes para encontrar a assinatura EOCD do ZIP
+                            const readSize = Math.min(stats.size, 1024);
+                            const buffer = Buffer.alloc(readSize);
+                            const fd = fs.openSync(res, "r");
+                            fs.readSync(fd, buffer, 0, readSize, stats.size - readSize);
+                            fs.closeSync(fd);
+
+                            if (!buffer.includes(zipEndSignature)) {
+                                corruptedJars.push(res);
+                            }
+                        } catch (e) {
+                            corruptedJars.push(res);
+                        }
+                    }
+                }
+            } catch (e) {}
+        };
+
+        for (const p of searchPaths) {
+            scan(p);
+        }
+
+        if (corruptedJars.length > 0) {
+            this.check(
+                "Integridade JAR",
+                false,
+                `${corruptedJars.length} arquivos corrompidos detectados.`,
+            );
+            if (fix) {
+                for (const file of corruptedJars) {
+                    try {
+                        fs.unlinkSync(file);
+                        console.log(`    ✔ Removido: ${path.basename(file)}`);
+                    } catch (e) {}
+                }
+                this.logger.success("JARs corrompidos removidos! Eles serão reconstruídos no próximo build.");
+                
+                // Limpar cache do Tomcat
+                this.logger.step("Limpando cache do Tomcat (work/temp)...");
+                const tomcatWork = path.join(config.tomcat.path, "work");
+                const tomcatTemp = path.join(config.tomcat.path, "temp");
+                [tomcatWork, tomcatTemp].forEach(p => {
+                    try {
+                        if (fs.existsSync(p)) {
+                            fs.rmSync(p, { recursive: true, force: true });
+                            fs.mkdirSync(p);
+                        }
+                    } catch (e) {}
+                });
+                this.logger.success("Cache do Tomcat limpo com sucesso.");
+            } else {
+                this.logger.warn(
+                    "Use 'xavva doctor --fix' para remover os JARs corrompidos e limpar o cache.",
+                );
+            }
+        } else {
+            this.check("Integridade JAR", true, "Todos os arquivos JAR parecem íntegros.");
+        }
+    }
+
+    private async checkBOM(fix: boolean) {
+        const srcPath = path.join(process.cwd(), "src");
+        if (!fs.existsSync(srcPath)) return;
+
+        const filesWithBOM: string[] = [];
+        const scan = (dir: string) => {
+            const list = fs.readdirSync(dir, { withFileTypes: true });
+            for (const item of list) {
+                const res = path.resolve(dir, item.name);
+                if (item.isDirectory()) {
+                    scan(res);
+                } else if (item.name.endsWith(".java")) {
+                    const buffer = fs.readFileSync(res);
+                    if (buffer[0] === 0xef && buffer[1] === 0xbb && buffer[2] === 0xbf) {
+                        filesWithBOM.push(res);
+                    }
+                }
+            }
+        };
+
+        scan(srcPath);
+
+        if (filesWithBOM.length > 0) {
+            this.check(
+                "Encoding BOM",
+                false,
+                `${filesWithBOM.length} arquivos com BOM (UTF-8 com assinatura)`,
+            );
+            if (fix) {
+                for (const file of filesWithBOM) {
+                    const buffer = fs.readFileSync(file);
+                    const cleanBuffer = buffer.subarray(3);
+                    fs.writeFileSync(file, cleanBuffer);
+                    console.log(
+                        `    ✔ Corrigido: ${path.basename(file)}`,
+                    );
+                }
+                this.logger.success("BOM removido de todos os arquivos!");
+            } else {
+                this.logger.warn(
+                    "Use 'xavva doctor --fix' para remover o BOM automaticamente.",
+                );
+            }
+        } else {
+            this.check("Encoding BOM", true, "Nenhum arquivo com BOM detectado.");
+        }
+    }
+
+    private check(label: string, ok: boolean, detail: string) {
+        const icon = ok ? "✔" : "✘";
+        console.log(`  ${icon} ${label.padEnd(15)} ${detail}`);
+    }
+
+    private checkBinary(name: string): boolean {
+        try {
+            const proc = Bun.spawnSync(getWhichCommand(name));
+            return proc.exitCode === 0;
+        } catch {
+            return false;
+        }
+    }
 
     private checkJVM(): { name: string, dcevm: boolean } {
         try {
@@ -252,8 +265,8 @@ export class DoctorCommand implements Command {
     }
 
     private async installDCEVM() {
-        Logger.section("Instalação do JetBrains Runtime (JBR 21)");
-        Logger.log("Baixando JDK moderna com DCEVM nativo (JBR 21 SDK)...");
+        this.logger.section("Instalação do JetBrains Runtime (JBR 21)");
+        this.logger.step("Baixando JDK moderna com DCEVM nativo (JBR 21 SDK)...");
         
         // URL para o JetBrains Runtime 21 SDK (multiplataforma)
         const url = getJbrDownloadUrl("21");
@@ -274,7 +287,7 @@ export class DoctorCommand implements Command {
             const tarPath = path.join(installDir, "jbr.tar.gz");
             fs.writeFileSync(tarPath, Buffer.from(buffer));
             
-            Logger.success("Download concluído. Extraindo binários...");
+            this.logger.success("Download concluído. Extraindo binários...");
             
             // Extrair .tar.gz usando comando apropriado para a plataforma
             const extractCmd = getTarExtractCommand(tarPath, installDir);
@@ -304,12 +317,12 @@ export class DoctorCommand implements Command {
                 await this.configureUnixEnv(jdkPath, binPath);
             }
         } catch (e: any) {
-            Logger.error(`Falha na instalação: ${e.message}`);
+            this.logger.error(`Falha na instalação: ${e.message}`);
         }
     }
 
     private async configureWindowsEnv(jdkPath: string, binPath: string) {
-        Logger.process("Configurando variáveis de ambiente do SISTEMA...");
+        this.logger.step("Configurando variáveis de ambiente do SISTEMA...");
 
         const setEnvCmd = `
             $jdk = $env:JDK_PATH;
@@ -345,20 +358,20 @@ export class DoctorCommand implements Command {
         const output = result.stdout.toString() + result.stderr.toString();
 
         if (output.includes("ACCESS_DENIED")) {
-            Logger.error("Falha ao configurar variáveis do SISTEMA (Acesso Negado).");
-            Logger.warn("Dica: Execute o terminal como ADMINISTRADOR para permitir esta alteração.");
-            Logger.info("JAVA_HOME manual", jdkPath);
+            this.logger.error("Falha ao configurar variáveis do SISTEMA (Acesso Negado).");
+            this.logger.warn("Dica: Execute o terminal como ADMINISTRADOR para permitir esta alteração.");
+            this.logger.config("JAVA_HOME manual", jdkPath);
         } else {
-            Logger.success(`DCEVM configurado no SISTEMA com sucesso!`);
-            Logger.info("JAVA_HOME", jdkPath);
+            this.logger.success(`DCEVM configurado no SISTEMA com sucesso!`);
+            this.logger.config("JAVA_HOME", jdkPath);
         }
 
-        Logger.newline();
-        Logger.warn("IMPORTANTE: Reinicie seu terminal (ou o VS Code) para as mudanças surtirem efeito.");
+        this.logger.newline();
+        this.logger.warn("IMPORTANTE: Reinicie seu terminal (ou o VS Code) para as mudanças surtirem efeito.");
     }
 
     private async configureUnixEnv(jdkPath: string, binPath: string) {
-        Logger.process("Configurando variáveis de ambiente...");
+        this.logger.step("Configurando variáveis de ambiente...");
 
         const shell = process.env.SHELL || "/bin/bash";
         let rcFile = path.join(os.homedir(), ".bashrc");
@@ -393,11 +406,11 @@ export class DoctorCommand implements Command {
 
         fs.writeFileSync(rcFile, filteredLines.join("\n") + "\n");
 
-        Logger.success(`DCEVM configurado em ${rcFile}`);
-        Logger.info("JAVA_HOME", jdkPath);
-        Logger.newline();
-        Logger.warn("IMPORTANTE: Execute 'source " + rcFile + "' ou reinicie seu terminal para aplicar permanentemente.");
-        Logger.info("Dica", "Para esta sessão, o JAVA_HOME já foi configurado temporariamente.");
+        this.logger.success(`DCEVM configurado em ${rcFile}`);
+        this.logger.config("JAVA_HOME", jdkPath);
+        this.logger.newline();
+        this.logger.warn("IMPORTANTE: Execute 'source " + rcFile + "' ou reinicie seu terminal para aplicar permanentemente.");
+        this.logger.info("Dica: Para esta sessão, o JAVA_HOME já foi configurado temporariamente.");
         
         // Configura JAVA_HOME temporariamente para o processo atual
         process.env.JAVA_HOME = jdkPath;

package/src/commands/EncodingCommand.ts

@@ -1,7 +1,7 @@
 import type { Command } from "./Command";
 import type { AppConfig, CLIArguments } from "../types/config";
 import { EncodingService } from "../services/EncodingService";
-import { Logger } from "../utils/ui";
+import { Logger, C } from "../utils/ui";
 import path from "path";
 import { existsSync } from "fs";
 import { ProcessManager } from "../utils/processManager";
@@ -54,19 +54,19 @@ export class EncodingCommand implements Command {
         Logger.log("Gerencia conversão de encoding de arquivos de texto");
         Logger.newline();
         
-        Logger.log(`${Logger.C.primary}Uso:${Logger.C.reset}`);
+        Logger.log(`${C.primary}Uso:${C.reset}`);
         Logger.log("  xavva encoding <subcomando> [arquivo] [opções]");
         Logger.newline();
         
-        Logger.log(`${Logger.C.primary}Subcomandos:${Logger.C.reset}`);
-        Logger.log(`  ${Logger.C.secondary}detect${Logger.C.reset} [arquivo]          Detecta encoding de um arquivo ou diretório`);
-        Logger.log(`  ${Logger.C.secondary}convert${Logger.C.reset} [arquivo]          Converte arquivo(s) para outro encoding`);
-        Logger.log(`  ${Logger.C.secondary}fix${Logger.C.reset} [arquivo]              Tenta corrigir mojibake automaticamente`);
-        Logger.log(`  ${Logger.C.secondary}list${Logger.C.reset}                     Lista encodings de todos os arquivos do projeto`);
-        Logger.log(`  ${Logger.C.secondary}help${Logger.C.reset}                     Mostra esta ajuda`);
+        Logger.log(`${C.primary}Subcomandos:${C.reset}`);
+        Logger.log(`  ${C.secondary}detect${C.reset} [arquivo]          Detecta encoding de um arquivo ou diretório`);
+        Logger.log(`  ${C.secondary}convert${C.reset} [arquivo]          Converte arquivo(s) para outro encoding`);
+        Logger.log(`  ${C.secondary}fix${C.reset} [arquivo]              Tenta corrigir mojibake automaticamente`);
+        Logger.log(`  ${C.secondary}list${C.reset}                     Lista encodings de todos os arquivos do projeto`);
+        Logger.log(`  ${C.secondary}help${C.reset}                     Mostra esta ajuda`);
         Logger.newline();
         
-        Logger.log(`${Logger.C.primary}Opções:${Logger.C.reset}`);
+        Logger.log(`${C.primary}Opções:${C.reset}`);
         Logger.log(`  --from <encoding>      Encoding de origem (padrão: auto-detect)`);
         Logger.log(`  --to <encoding>        Encoding de destino (padrão: do xavva.json ou UTF-8)`);
         Logger.log(`  --backup               Cria backup antes de converter`);
@@ -75,13 +75,13 @@ export class EncodingCommand implements Command {
         Logger.log(`  --src <path>           Diretório fonte (padrão: src/)`);
         Logger.newline();
         
-        Logger.log(`${Logger.C.primary}Encodings suportados:${Logger.C.reset}`);
+        Logger.log(`${C.primary}Encodings suportados:${C.reset}`);
         Logger.log(`  utf-8, utf8            UTF-8 (padrão)`);
         Logger.log(`  windows-1252, cp1252   Windows CP1252 (ANSI)`);
         Logger.log(`  iso-8859-1, latin1     ISO-8859-1 (Latin-1)`);
         Logger.newline();
         
-        Logger.log(`${Logger.C.primary}Exemplos:${Logger.C.reset}`);
+        Logger.log(`${C.primary}Exemplos:${C.reset}`);
         Logger.log(`  xavva encoding detect src/main/java/MinhaClasse.java`);
         Logger.log(`  xavva encoding convert --from utf-8 --to cp1252 src/main/java/`);
         Logger.log(`  xavva encoding convert --to cp1252 --backup src/main/java/MinhaClasse.java`);
@@ -135,13 +135,13 @@ export class EncodingCommand implements Command {
             Logger.info("Arquivos analisados", String(detections.size));
             Logger.newline();
 
-            Logger.log(`${Logger.C.primary}Distribuição por encoding:${Logger.C.reset}`);
+            Logger.log(`${C.primary}Distribuição por encoding:${C.reset}`);
             for (const [encoding, count] of byEncoding) {
                 Logger.config(encoding, `${count} arquivo(s)`);
             }
 
             Logger.newline();
-            Logger.log(`${Logger.C.primary}Arquivos com baixa confiança:${Logger.C.reset}`);
+            Logger.log(`${C.primary}Arquivos com baixa confiança:${C.reset}`);
             let lowConfidenceFound = false;
             for (const [file, detection] of detections) {
                 if (detection.confidence < 0.8) {
@@ -339,18 +339,18 @@ export class EncodingCommand implements Command {
         // Ordena arquivos
         const sortedFiles = Array.from(detections.entries()).sort((a, b) => a[0].localeCompare(b[0]));
 
-        Logger.log(`${Logger.C.primary}Arquivos:${Logger.C.reset}`);
+        Logger.log(`${C.primary}Arquivos:${C.reset}`);
         for (const [file, detection] of sortedFiles) {
             const relativePath = path.relative(srcDir, file);
             const confidenceStr = detection.confidence >= 0.9 ? "" : 
-                ` ${Logger.C.gray}(${Math.round(detection.confidence * 100)}%)${Logger.C.reset}`;
-            const bomStr = detection.hasBOM ? ` ${Logger.C.warning}[BOM]${Logger.C.reset}` : "";
+                ` ${C.gray}(${Math.round(detection.confidence * 100)}%)${C.reset}`;
+            const bomStr = detection.hasBOM ? ` ${C.warning}[BOM]${C.reset}` : "";
             
             const encodingColor = detection.encoding === (config.project.encoding || "utf-8") 
-                ? Logger.C.success 
-                : Logger.C.warning;
+                ? C.success 
+                : C.warning;
             
-            Logger.log(`  ${encodingColor}${detection.encoding.padEnd(12)}${Logger.C.reset} ${relativePath}${confidenceStr}${bomStr}`);
+            Logger.log(`  ${encodingColor}${detection.encoding.padEnd(12)}${C.reset} ${relativePath}${confidenceStr}${bomStr}`);
         }
 
         Logger.endSection();