@archznn/xavva 2.0.3 → 2.2.0

package/src/services/DependencyAnalyzerService.ts

@@ -0,0 +1,538 @@
+import fs from "fs";
+import path from "path";
+import type { ProjectConfig } from "../types/config";
+import { Logger } from "../utils/ui";
+
+export interface Dependency {
+	groupId: string;
+	artifactId: string;
+	version: string;
+	scope?: string;
+	type: "direct" | "transitive";
+}
+
+export interface DependencyConflict {
+	artifactId: string;
+	groupId: string;
+	versions: string[];
+	locations: string[];
+	severity: "warning" | "error";
+}
+
+export interface DependencyUpdate {
+	groupId: string;
+	artifactId: string;
+	currentVersion: string;
+	latestVersion: string;
+	isMajor: boolean;
+	changelog?: string;
+}
+
+export interface DependencyAnalysisResult {
+	dependencies: Dependency[];
+	conflicts: DependencyConflict[];
+	updates: DependencyUpdate[];
+	outdated: Dependency[];
+	stats: {
+		total: number;
+		direct: number;
+		transitive: number;
+		vulnerable: number;
+		outdatedCount: number;
+	};
+}
+
+interface MavenDependency {
+	groupId: string;
+	artifactId: string;
+	version: string;
+	scope?: string;
+	optional?: boolean;
+}
+
+export class DependencyAnalyzerService {
+	constructor(private projectConfig: ProjectConfig) {}
+
+	async analyze(): Promise<DependencyAnalysisResult> {
+		const deps = await this.extractDependencies();
+		const conflicts = this.detectConflicts(deps);
+		const updates = await this.checkUpdates(deps);
+		const outdated = deps.filter(d => updates.some(u => 
+			u.groupId === d.groupId && u.artifactId === d.artifactId
+		));
+
+		return {
+			dependencies: deps,
+			conflicts,
+			updates,
+			outdated,
+			stats: {
+				total: deps.length,
+				direct: deps.filter(d => d.type === "direct").length,
+				transitive: deps.filter(d => d.type === "transitive").length,
+				vulnerable: 0, // Será preenchido pelo AuditService
+				outdatedCount: outdated.length
+			}
+		};
+	}
+
+	private async extractDependencies(): Promise<Dependency[]> {
+		if (this.projectConfig.buildTool === "maven") {
+			return this.extractMavenDependencies();
+		} else {
+			return this.extractGradleDependencies();
+		}
+	}
+
+	private verbose: boolean = false;
+
+	setVerbose(verbose: boolean) {
+		this.verbose = verbose;
+	}
+
+	private async extractMavenDependencies(): Promise<Dependency[]> {
+		const deps: Dependency[] = [];
+		const pomPath = path.join(process.cwd(), "pom.xml");
+		
+		if (!fs.existsSync(pomPath)) {
+			Logger.warn("pom.xml não encontrado");
+			return deps;
+		}
+
+		if (this.verbose) {
+			Logger.info("Tentando extrair dependências do Maven...", "");
+		}
+
+		// Tentar várias estratégias para extrair dependências
+		
+		// 1. Tentar mvn dependency:tree
+		try {
+			const mvnCmd = process.platform === "win32" ? "mvn.cmd" : "mvn";
+			Logger.step("Executando mvn dependency:tree...");
+			
+			const output = Bun.spawnSync([
+				mvnCmd,
+				"dependency:tree",
+				"-DoutputType=text",
+				"-q"
+			], { cwd: process.cwd() });
+
+			if (output.exitCode === 0) {
+				const treeOutput = output.stdout.toString();
+				const parsed = this.parseMavenTree(treeOutput);
+				if (parsed.length > 0) {
+					Logger.success(`Encontradas ${parsed.length} dependências via Maven tree`);
+					return parsed;
+				}
+			} else {
+				const errorOutput = output.stderr.toString();
+				if (this.verbose) {
+					Logger.warn(`mvn dependency:tree falhou: ${errorOutput.substring(0, 200)}`);
+				}
+			}
+		} catch (e) {
+			if (this.verbose) {
+				Logger.warn(`Não foi possível executar mvn dependency:tree: ${e}`);
+			}
+		}
+
+		// 2. Fallback: Parse direto do pom.xml
+		Logger.step("Analisando pom.xml diretamente...");
+		const pomDeps = this.parsePomDirect();
+		if (pomDeps.length > 0) {
+			Logger.success(`Encontradas ${pomDeps.length} dependências no pom.xml`);
+			return pomDeps;
+		}
+
+		// 3. Último recurso: Verificar pasta lib do Tomcat (se existir)
+		const libDeps = await this.extractFromLibFolder();
+		if (libDeps.length > 0) {
+			Logger.success(`Encontradas ${libDeps.length} dependências na pasta lib`);
+			return libDeps;
+		}
+
+		Logger.warn("Nenhuma dependência encontrada");
+		return deps;
+	}
+
+	private async extractFromLibFolder(): Promise<Dependency[]> {
+		const deps: Dependency[] = [];
+		const libPath = path.join(process.cwd(), "target", "dependency");
+		
+		if (!fs.existsSync(libPath)) {
+			// Tentar gerar com mvn dependency:copy-dependencies
+			try {
+				const mvnCmd = process.platform === "win32" ? "mvn.cmd" : "mvn";
+				Logger.step("Tentando baixar dependências...");
+				Bun.spawnSync([
+					mvnCmd,
+					"dependency:copy-dependencies",
+					"-DoutputDirectory=target/dependency",
+					"-q"
+				], { cwd: process.cwd() });
+			} catch (e) {
+				return deps;
+			}
+		}
+
+		if (fs.existsSync(libPath)) {
+			const files = fs.readdirSync(libPath).filter(f => f.endsWith(".jar"));
+			for (const file of files) {
+				const parsed = this.parseJarName(file);
+				if (parsed) {
+					deps.push({ ...parsed, type: "direct" });
+				}
+			}
+		}
+
+		return deps;
+	}
+
+	private parseJarName(jarName: string): { groupId: string; artifactId: string; version: string } | null {
+		// Remove .jar extension
+		const name = jarName.replace(/\.jar$/, "");
+		
+		// Tenta extrair: artifactId-version
+		const match = name.match(/^(.+?)-(\d[\d\.-]*(?:-SNAPSHOT)?)$/);
+		if (match) {
+			return {
+				groupId: "unknown", // Não conseguimos extrair do nome do JAR
+				artifactId: match[1],
+				version: match[2]
+			};
+		}
+		
+		return null;
+	}
+
+	private parseMavenTree(output: string): Dependency[] {
+		const deps: Dependency[] = [];
+		const lines = output.split("\n");
+		const seen = new Set<string>();
+
+		for (const line of lines) {
+			// Pattern: [INFO] |  |  \- org.springframework:spring-core:jar:5.3.9:compile
+			// ou: [INFO] +- org.springframework:spring-core:jar:5.3.9:compile
+			const match = line.match(/[\\|\-+]\s+([^:]+):([^:]+):[^:]+:([^:]+):?(\w+)?/);
+			if (match) {
+				const [, groupId, artifactId, version, scope] = match;
+				const key = `${groupId}:${artifactId}:${version}`;
+				
+				if (!seen.has(key)) {
+					seen.add(key);
+					// Determina se é direto ou transitivo pelo nível de indentação
+					const level = (line.match(/[|\\]/g) || []).length;
+					deps.push({
+						groupId,
+						artifactId,
+						version,
+						scope: scope || "compile",
+						type: level <= 1 ? "direct" : "transitive"
+					});
+				}
+			}
+		}
+
+		return deps;
+	}
+
+	private parsePomDirect(): Dependency[] {
+		const deps: Dependency[] = [];
+		const pomPath = path.join(process.cwd(), "pom.xml");
+		
+		try {
+			const content = fs.readFileSync(pomPath, "utf-8");
+			
+			// Remove comentários XML para não interferir no parse
+			const cleanContent = content.replace(/<!--[\s\S]*?-->/g, "");
+			
+			// Parse de dependencies - suporta propriedades ${...}
+			const depRegex = /<dependency>\s*([\s\S]*?)<\/dependency>/g;
+			let match;
+			
+			while ((match = depRegex.exec(cleanContent)) !== null) {
+				const depBlock = match[1];
+				
+				// Extrai groupId
+				let groupId = depBlock.match(/<groupId>\s*([^<$]+)\s*<\/groupId>/)?.[1]?.trim();
+				// Extrai artifactId
+				let artifactId = depBlock.match(/<artifactId>\s*([^<$]+)\s*<\/artifactId>/)?.[1]?.trim();
+				// Extrai version
+				let version = depBlock.match(/<version>\s*([^<$]+)\s*<\/version>/)?.[1]?.trim();
+				// Extrai scope
+				const scope = depBlock.match(/<scope>\s*([^<$]+)\s*<\/scope>/)?.[1]?.trim();
+				
+				// Resolve propriedades simples ${property}
+				if (version?.startsWith("${")) {
+					const propName = version.slice(2, -1);
+					const propValue = cleanContent.match(new RegExp(`<${propName}>([^<]+)</${propName}>`))?.[1];
+					if (propValue) version = propValue.trim();
+				}
+				
+				if (groupId && artifactId) {
+					// Se não tiver versão, tenta encontrar no dependencyManagement
+					if (!version || version.startsWith("${")) {
+						version = this.findVersionInDependencyManagement(cleanContent, groupId, artifactId) || version || "managed";
+					}
+					
+					deps.push({
+						groupId,
+						artifactId,
+						version,
+						scope,
+						type: "direct"
+					});
+				}
+			}
+			
+			Logger.info("Dependências encontradas no pom.xml", String(deps.length));
+		} catch (e) {
+			Logger.warn(`Não foi possível analisar o pom.xml: ${e}`);
+		}
+
+		return deps;
+	}
+	
+	private findVersionInDependencyManagement(content: string, groupId: string, artifactId: string): string | null {
+		// Busca no dependencyManagement
+		const dmMatch = content.match(/<dependencyManagement>\s*<dependencies>([\s\S]*?)<\/dependencies>\s*<\/dependencyManagement>/);
+		if (dmMatch) {
+			const dmBlock = dmMatch[1];
+			const depRegex = /<dependency>\s*([\s\S]*?)<\/dependency>/g;
+			let match;
+			
+			while ((match = depRegex.exec(dmBlock)) !== null) {
+				const depBlock = match[1];
+				const depGroupId = depBlock.match(/<groupId>\s*([^<]+)\s*<\/groupId>/)?.[1]?.trim();
+				const depArtifactId = depBlock.match(/<artifactId>\s*([^<]+)\s*<\/artifactId>/)?.[1]?.trim();
+				const depVersion = depBlock.match(/<version>\s*([^<]+)\s*<\/version>/)?.[1]?.trim();
+				
+				if (depGroupId === groupId && depArtifactId === artifactId && depVersion) {
+					return depVersion;
+				}
+			}
+		}
+		return null;
+	}
+
+	private async extractGradleDependencies(): Promise<Dependency[]> {
+		const deps: Dependency[] = [];
+		
+		try {
+			const gradleCmd = process.platform === "win32" ? "gradle.bat" : "gradle";
+			const output = Bun.spawnSync([
+				gradleCmd,
+				"dependencies",
+				"--configuration",
+				"runtimeClasspath",
+				"-q"
+			], { cwd: process.cwd() });
+
+			if (output.exitCode === 0) {
+				deps.push(...this.parseGradleTree(output.stdout.toString()));
+			}
+		} catch (e) {
+			Logger.warn("Não foi possível executar gradle dependencies");
+		}
+
+		return deps;
+	}
+
+	private parseGradleTree(output: string): Dependency[] {
+		const deps: Dependency[] = [];
+		const lines = output.split("\n");
+		const seen = new Set<string>();
+
+		for (const line of lines) {
+			// Pattern: |    |    +--- org.springframework:spring-core:5.3.9
+			const match = line.match(/[\\|\-+]+\s+([^:]+):([^:]+):([^\s]+)/);
+			if (match) {
+				const [, groupId, artifactId, version] = match;
+				const key = `${groupId}:${artifactId}:${version}`;
+				
+				if (!seen.has(key)) {
+					seen.add(key);
+					const level = (line.match(/[|\\]/g) || []).length;
+					deps.push({
+						groupId,
+						artifactId,
+						version,
+						type: level <= 1 ? "direct" : "transitive"
+					});
+				}
+			}
+		}
+
+		return deps;
+	}
+
+	private detectConflicts(deps: Dependency[]): DependencyConflict[] {
+		const conflicts: DependencyConflict[] = [];
+		const grouped = new Map<string, Dependency[]>();
+
+		// Agrupar por groupId:artifactId
+		for (const dep of deps) {
+			const key = `${dep.groupId}:${dep.artifactId}`;
+			if (!grouped.has(key)) {
+				grouped.set(key, []);
+			}
+			grouped.get(key)!.push(dep);
+		}
+
+		// Detectar conflitos (mesmo artifact, versões diferentes)
+		for (const [key, versions] of grouped) {
+			const uniqueVersions = [...new Set(versions.map(v => v.version))];
+			if (uniqueVersions.length > 1) {
+				const [groupId, artifactId] = key.split(":");
+				const hasDirect = versions.some(v => v.type === "direct");
+				
+				conflicts.push({
+					groupId,
+					artifactId,
+					versions: uniqueVersions,
+					locations: versions.map(v => v.scope || "compile"),
+					severity: hasDirect ? "error" : "warning"
+				});
+			}
+		}
+
+		return conflicts;
+	}
+
+	private async checkUpdates(deps: Dependency[]): Promise<DependencyUpdate[]> {
+		const updates: DependencyUpdate[] = [];
+		const directDeps = deps.filter(d => d.type === "direct");
+
+		// Verificar atualizações em paralelo (com limite)
+		const chunkSize = 5;
+		for (let i = 0; i < directDeps.length; i += chunkSize) {
+			const chunk = directDeps.slice(i, i + chunkSize);
+			const promises = chunk.map(dep => this.checkSingleUpdate(dep));
+			const results = await Promise.all(promises);
+			updates.push(...results.filter((u): u is DependencyUpdate => u !== null));
+		}
+
+		return updates;
+	}
+
+	private async checkSingleUpdate(dep: Dependency): Promise<DependencyUpdate | null> {
+		try {
+			const latest = await this.fetchLatestVersion(dep.groupId, dep.artifactId);
+			if (latest && this.isNewer(latest, dep.version)) {
+				return {
+					groupId: dep.groupId,
+					artifactId: dep.artifactId,
+					currentVersion: dep.version,
+					latestVersion: latest,
+					isMajor: this.isMajorUpdate(dep.version, latest)
+				};
+			}
+		} catch (e) {
+			// Silenciar erros de rede
+		}
+		return null;
+	}
+
+	private async fetchLatestVersion(groupId: string, artifactId: string): Promise<string | null> {
+		// Usar Maven Central API
+		try {
+			const url = `https://search.maven.org/solrsearch/select?q=g:"${groupId}"+AND+a:"${artifactId}"&rows=1&wt=json`;
+			const response = await fetch(url, { signal: AbortSignal.timeout(5000) });
+			const data = await response.json();
+			
+			if (data.response?.docs?.[0]?.latestVersion) {
+				return data.response.docs[0].latestVersion;
+			}
+		} catch (e) {
+			// Fallback silencioso
+		}
+		return null;
+	}
+
+	private isNewer(latest: string, current: string): boolean {
+		return this.compareVersions(latest, current) > 0;
+	}
+
+	private isMajorUpdate(current: string, latest: string): boolean {
+		const currentMajor = current.split(".")[0];
+		const latestMajor = latest.split(".")[0];
+		return currentMajor !== latestMajor;
+	}
+
+	private compareVersions(v1: string, v2: string): number {
+		const parts1 = v1.split(/[.-]/).filter(p => /^\d+$/.test(p)).map(Number);
+		const parts2 = v2.split(/[.-]/).filter(p => /^\d+$/.test(p)).map(Number);
+		
+		for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+			const p1 = parts1[i] || 0;
+			const p2 = parts2[i] || 0;
+			if (p1 !== p2) return p1 - p2;
+		}
+		return 0;
+	}
+
+	generateReport(result: DependencyAnalysisResult): string {
+		const lines: string[] = [];
+		lines.push("");
+		lines.push(`${Logger.C.cyan}══════════════════════════════════════════════════════════${Logger.C.reset}`);
+		lines.push(`${Logger.C.bold}📊 ANÁLISE DE DEPENDÊNCIAS${Logger.C.reset}`);
+		lines.push(`${Logger.C.cyan}══════════════════════════════════════════════════════════${Logger.C.reset}`);
+		lines.push("");
+		
+		// Estatísticas
+		lines.push(`${Logger.C.dim}Estatísticas:${Logger.C.reset}`);
+		lines.push(`  Total: ${result.stats.total} dependências`);
+		lines.push(`  Diretas: ${result.stats.direct} | Transitivas: ${result.stats.transitive}`);
+		lines.push("");
+
+		// Conflitos
+		if (result.conflicts.length > 0) {
+			lines.push(`${Logger.C.yellow}⚠️  CONFLITOS DE VERSÃO (${result.conflicts.length})${Logger.C.reset}`);
+			for (const conflict of result.conflicts) {
+				const icon = conflict.severity === "error" ? "✖" : "▲";
+				const color = conflict.severity === "error" ? Logger.C.red : Logger.C.yellow;
+				lines.push(`  ${color}${icon}${Logger.C.reset} ${conflict.groupId}:${conflict.artifactId}`);
+				lines.push(`     Versões: ${conflict.versions.join(", ")}`);
+			}
+			lines.push("");
+		}
+
+		// Atualizações
+		if (result.updates.length > 0) {
+			const majorUpdates = result.updates.filter(u => u.isMajor);
+			const minorUpdates = result.updates.filter(u => !u.isMajor);
+
+			if (minorUpdates.length > 0) {
+				lines.push(`${Logger.C.green}⬆️  ATUALIZAÇÕES DISPONÍVEIS (${minorUpdates.length})${Logger.C.reset}`);
+				for (const update of minorUpdates.slice(0, 5)) {
+					lines.push(`  ${Logger.C.green}↑${Logger.C.reset} ${update.groupId}:${update.artifactId}`);
+					lines.push(`     ${update.currentVersion} → ${Logger.C.green}${update.latestVersion}${Logger.C.reset}`);
+				}
+				if (minorUpdates.length > 5) {
+					lines.push(`  ${Logger.C.dim}... e mais ${minorUpdates.length - 5}${Logger.C.reset}`);
+				}
+				lines.push("");
+			}
+
+			if (majorUpdates.length > 0) {
+				lines.push(`${Logger.C.yellow}⚠️  ATUALIZAÇÕES MAJOR (${majorUpdates.length})${Logger.C.reset}`);
+				lines.push(`  ${Logger.C.dim}Podem conter breaking changes${Logger.C.reset}`);
+				for (const update of majorUpdates.slice(0, 3)) {
+					lines.push(`  ${Logger.C.yellow}!${Logger.C.reset} ${update.groupId}:${update.artifactId}`);
+					lines.push(`     ${update.currentVersion} → ${Logger.C.yellow}${update.latestVersion}${Logger.C.reset}`);
+				}
+				lines.push("");
+			}
+		}
+
+		// Resumo
+		if (result.conflicts.length === 0 && result.updates.length === 0) {
+			lines.push(`${Logger.C.green}✔ Todas as dependências estão atualizadas!${Logger.C.reset}`);
+		}
+
+		lines.push("");
+		lines.push(`${Logger.C.dim}Dica: Execute 'xavva audit' para verificar vulnerabilidades${Logger.C.reset}`);
+		
+		return lines.join("\n");
+	}
+}

package/src/services/ProjectService.ts

@@ -1,4 +1,4 @@
-import { existsSync, readdirSync, statSync } from "fs";
+import { existsSync, readdirSync, statSync, readFileSync } from "fs";
 import path from "path";
 import type { ProjectConfig } from "../types/config";
 
@@ -96,7 +96,7 @@ export class ProjectService {
             const pomPath = path.join(root, "pom.xml");
             if (existsSync(pomPath)) {
                 try {
-                    const content = require("fs").readFileSync(pomPath, "utf8");
+                    const content = readFileSync(pomPath, "utf8");
                     // Regex simples para capturar IDs de profiles no pom.xml
                     const profileRegex = /<profile>[\s\S]*?<id>(.*?)<\/id>/g;
                     let match;
@@ -112,7 +112,7 @@ export class ProjectService {
 
             if (targetPath) {
                 try {
-                    const content = require("fs").readFileSync(targetPath, "utf8");
+                    const content = readFileSync(targetPath, "utf8");
                     // Em Gradle, perfis costumam ser tratados via propriedades ou tasks de ambiente
                     // Vamos procurar por padrões comuns como "if (project.hasProperty('profile'))" 
                     // ou simplesmente sugerir o uso de -P

package/src/services/TomcatService.ts

@@ -2,6 +2,9 @@ import type { TomcatConfig, AppConfig } from "../types/config";
 import { Logger } from "../utils/ui";
 import type { Subprocess } from "bun";
 import { ProjectService } from "./ProjectService";
+import { existsSync, mkdirSync, writeFileSync, promises as fs } from "fs";
+import path from "path";
+import os from "os";
 
 export class TomcatService {
 	private activeConfig: TomcatConfig;
@@ -43,9 +46,6 @@ export class TomcatService {
 	}
 
 	async clearWebapps() {
-		const fs = require("fs").promises;
-		const { existsSync } = require("fs");
-		const path = require("path");
 		const webappsPath = path.join(this.activeConfig.path, "webapps");
 		const workPath = path.join(this.activeConfig.path, "work");
 		const tempPath = path.join(this.activeConfig.path, "temp");
@@ -95,9 +95,6 @@ export class TomcatService {
 	}
 
 	private async ensureHotswapAgent(): Promise<string | null> {
-		const fs = require("fs");
-		const path = require("path");
-		const os = require("os");
 		const agentDir = path.join(os.homedir(), ".xavva", "agents");
 		const agentPath = path.join(agentDir, "hotswap-agent-2.0.3.jar");
 
@@ -134,7 +131,7 @@ export class TomcatService {
 				
 				let javaBin = "java";
 				if (process.env.JAVA_HOME) {
-					javaBin = require("path").join(process.env.JAVA_HOME, "bin", "java.exe");
+					javaBin = path.join(process.env.JAVA_HOME, "bin", "java.exe");
 				}
 
 				const javaVer = Bun.spawnSync([javaBin, "-version"]);
@@ -159,14 +156,13 @@ export class TomcatService {
 					"--add-opens=java.desktop/java.beans=ALL-UNNAMED"
 				);
 				
-				const fs = require("fs");
-				const path = require("path");
+
 				const xavvaDir = path.join(process.cwd(), ".xavva");
-				if (!fs.existsSync(xavvaDir)) fs.mkdirSync(xavvaDir, { recursive: true });
+				if (!existsSync(xavvaDir)) mkdirSync(xavvaDir, { recursive: true });
 				
 				const propsPath = path.join(xavvaDir, "hotswap-agent.properties");
 				const propsContent = `autoHotswap=true\nautoHotswap.delay=500\nwatchResources=false\nLOGGER=info`;
-				fs.writeFileSync(propsPath, propsContent);
+				writeFileSync(propsPath, propsContent);
 				
 				catalinaOpts.push(`-Dhotswap-agent.properties.path=${propsPath}`);
 
@@ -186,6 +182,10 @@ export class TomcatService {
 			"-Dorg.apache.jasper.compiler.classdebuginfo=true"
 		);
 
+		if (config.project.encoding) {
+			catalinaOpts.push(`-Dfile.encoding=${config.project.encoding}`);
+		}
+
 		if (config.project.skipScan) {
 			catalinaOpts.push(
 				"-Dtomcat.util.scan.StandardJarScanFilter.jarsToSkip=*.jar",

package/src/services/WatcherService.ts

@@ -1,6 +1,7 @@
 import { watch } from "fs";
 import { Logger } from "../utils/ui";
 import { DeployCommand } from "../commands/DeployCommand";
+import { WATCHER_DEBOUNCE_MS, WATCHER_COOLING_MS } from "../utils/constants";
 import type { AppConfig } from "../types/config";
 
 export class WatcherService {
@@ -19,7 +20,7 @@ export class WatcherService {
 
             if (this.coolingFiles.has(filename)) return;
             this.coolingFiles.add(filename);
-            setTimeout(() => this.coolingFiles.delete(filename), 500);
+            setTimeout(() => this.coolingFiles.delete(filename), WATCHER_COOLING_MS);
 
             if (this.isIgnored(filename)) return;
 
@@ -47,7 +48,7 @@ export class WatcherService {
             this.debounceTimer = setTimeout(() => {
                 this.run(this.pendingFullBuild ? false : true);
                 this.pendingFullBuild = false;
-            }, 1000);
+            }, WATCHER_DEBOUNCE_MS);
         });
     }
 

package/src/types/config.ts

@@ -19,6 +19,7 @@ export interface ProjectConfig {
     cleanLogs: boolean;
     grep?: string;
     tui: boolean;
+    encoding?: string;
 }
 
 export interface AppConfig {
@@ -31,6 +32,7 @@ export interface CLIArguments {
     tool?: string;
     name?: string;
     port?: string;
+    encoding?: string;
     "no-build"?: boolean;
     scan?: boolean;
     clean?: boolean;
@@ -46,6 +48,8 @@ export interface CLIArguments {
     fix?: boolean;
     incremental?: boolean;
     tui?: boolean;
+    output?: string;
+    strict?: boolean;
 }
 
 export interface CommandContext {