@carlos-iso/versioner 0.0.2

package/src/managers/GitManager.js

@@ -0,0 +1,135 @@
+const { execFileSync } = require("child_process");
+
+class GitManager {
+	constructor(cwd = process.cwd()) {
+		this.cwd = cwd;
+	}
+
+	/**
+	 * Executa um comando git.
+	 * Usa execFileSync com array de argumentos: a mensagem de commit
+	 * nunca passa pelo shell, então aspas e $ não quebram nada.
+	 */
+	run(args, { silent = false } = {}) {
+		return execFileSync("git", args, {
+			cwd: this.cwd,
+			stdio: silent ? ["ignore", "pipe", "pipe"] : "inherit",
+			encoding: "utf8",
+		});
+	}
+
+	/**
+	 * Executa e devolve a saída, sem lançar erro.
+	 */
+	query(args) {
+		try {
+			return String(this.run(args, { silent: true }) || "").trim();
+		} catch {
+			return null;
+		}
+	}
+
+	isInstalled() {
+		return this.query(["--version"]) !== null;
+	}
+
+	isRepository() {
+		return this.query(["rev-parse", "--is-inside-work-tree"]) === "true";
+	}
+
+	branch() {
+		return this.query(["rev-parse", "--abbrev-ref", "HEAD"]);
+	}
+
+	hasRemote() {
+		const remotes = this.query(["remote"]);
+
+		return Boolean(remotes && remotes.length);
+	}
+
+	hasUpstream() {
+		return this.query(["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"]) !== null;
+	}
+
+	/**
+	 * Lista de arquivos modificados (porcelain).
+	 */
+	changes() {
+		const output = this.query(["status", "--porcelain"]);
+
+		if (!output) {
+			return [];
+		}
+
+		return output
+			.split("\n")
+			.map((line) => line.trim())
+			.filter(Boolean);
+	}
+
+	hasChanges() {
+		return this.changes().length > 0;
+	}
+
+	lastCommit() {
+		return this.query(["log", "-1", "--pretty=%s"]);
+	}
+
+	add() {
+		this.run(["add", "."]);
+
+		return { success: true };
+	}
+
+	commit(message) {
+		this.run(["commit", "-m", message]);
+
+		return { success: true };
+	}
+
+	push() {
+		if (!this.hasRemote()) {
+			return { success: false, skipped: true, reason: "nenhum remoto configurado" };
+		}
+
+		if (!this.hasUpstream()) {
+			const branch = this.branch();
+
+			this.run(["push", "--set-upstream", "origin", branch]);
+
+			return { success: true, upstream: true };
+		}
+
+		this.run(["push"]);
+
+		return { success: true };
+	}
+
+	tagExists(name) {
+		const output = this.query(["tag", "--list", name]);
+
+		return Boolean(output && output.length);
+	}
+
+	tag(name, message) {
+		if (this.tagExists(name)) {
+			return { success: false, skipped: true, reason: "tag já existe" };
+		}
+
+		this.run(["tag", "-a", name, "-m", message || name]);
+
+		return { success: true };
+	}
+
+	pushTags() {
+		if (!this.hasRemote()) {
+			return { success: false, skipped: true, reason: "nenhum remoto configurado" };
+		}
+
+		this.run(["push", "--tags"]);
+
+		return { success: true };
+	}
+}
+
+module.exports = GitManager;

package/src/managers/ReleaseManager.js

@@ -0,0 +1,301 @@
+const VersionManager = require("./VersionManager");
+const ConfigManager = require("./ConfigManager");
+const FileManager = require("./FileManager");
+const GitManager = require("./GitManager");
+
+const logger = require("../utils/logger");
+const { formatDuration } = require("../utils/time");
+const { hasFlag } = require("../utils/args");
+const { VERSION_TYPES } = require("../constants");
+
+/**
+ * Orquestra o fluxo de release.
+ * Nenhuma regra de negócio fica no run(): apenas a sequência de etapas.
+ */
+class ReleaseManager {
+	constructor(cwd = process.cwd()) {
+		this.cwd = cwd;
+
+		this.configManager = new ConfigManager(cwd);
+		this.fileManager = new FileManager(cwd);
+		this.gitManager = new GitManager(cwd);
+
+		// Criado em loadConfig(), pois depende de config.versionFile.
+		this.versionManager = null;
+	}
+
+	async run(context) {
+		try {
+			logger.title(`Versioner · ${context.type}`);
+
+			this.validate(context);
+			this.loadConfig(context);
+			this.version(context);
+			this.updateFiles(context);
+			this.git(context);
+			this.finish(context);
+
+			return 0;
+		} catch (error) {
+			this.rollback(context, error);
+
+			return 1;
+		}
+	}
+
+	// ── Etapas ────────────────────────────────────────────────
+
+	validate(context) {
+		if (!VERSION_TYPES.includes(context.type)) {
+			throw new Error("Tipo de release inválido. Utilize: build, minor ou major.");
+		}
+
+		context.dryRun = hasFlag(context.flags, "dry-run");
+
+		if (!this.gitManager.isInstalled()) {
+			throw new Error("Git não encontrado no sistema.");
+		}
+
+		if (this.useGit(context) && !this.gitManager.isRepository()) {
+			throw new Error(
+				'Este diretório não é um repositório Git. Use "git init" ou rode com --no-git.',
+			);
+		}
+	}
+
+	loadConfig(context) {
+		context.config = this.configManager.load();
+
+		this.versionManager = new VersionManager(this.cwd, context.config.versionFile);
+
+		this.validateMessage(context);
+
+		logger.success("Configuração carregada.");
+	}
+
+	validateMessage(context) {
+		const { minLength, maxLength } = context.config.commit;
+
+		const message = String(context.message || "").trim();
+
+		if (!message) {
+			throw new Error(
+				`Informe uma mensagem para o commit. Exemplo: versioner ${context.type} "Corrige login"`,
+			);
+		}
+
+		if (message.length < minLength) {
+			throw new Error(
+				`A mensagem do commit deve ter no mínimo ${minLength} caracteres.`,
+			);
+		}
+
+		if (message.length > maxLength) {
+			throw new Error(
+				`A mensagem do commit deve ter no máximo ${maxLength} caracteres.`,
+			);
+		}
+
+		context.message = message;
+	}
+
+	version(context) {
+		const result = this.versionManager.increment(context.type, {
+			dryRun: context.dryRun,
+		});
+
+		context.previous = result.previous;
+		context.current = result.current;
+		context.previousVersion = result.previousVersion;
+		context.version = result.version;
+
+		logger.success(`Versão ${context.previousVersion} → ${logger.bold(context.version)}`);
+
+		logger.info(`Mensagem: ${context.message}`);
+	}
+
+	updateFiles(context) {
+		const files = context.config.files;
+
+		if (!files.length) {
+			logger.warn("Nenhum arquivo monitorado na configuração.");
+			return;
+		}
+
+		logger.info("Atualizando arquivos...");
+
+		for (const file of files) {
+			const result = this.fileManager.update(file, context.version, {
+				dryRun: context.dryRun,
+			});
+
+			if (!result.updated) {
+				context.skipped.push({ path: file.path, reason: result.reason });
+
+				logger.muted(`  ${file.path} ignorado (${result.reason})`);
+				continue;
+			}
+
+			context.files.push(file.path);
+
+			logger.success(`  ${file.path} → ${file.field}`);
+		}
+	}
+
+	git(context) {
+		if (!this.useGit(context)) {
+			logger.warn("Etapa do Git ignorada.");
+			return;
+		}
+
+		const git = context.config.git;
+
+		logger.info("Executando Git...");
+
+		context.git.branch = this.gitManager.branch();
+
+		if (context.dryRun) {
+			logger.muted("  dry-run: nenhum comando Git foi executado.");
+			return;
+		}
+
+		if (git.add) {
+			this.gitManager.add();
+			context.git.add = true;
+			logger.success("  git add");
+		}
+
+		if (git.commit) {
+			const message = this.buildCommitMessage(context);
+
+			this.gitManager.commit(message);
+			context.git.commit = true;
+			logger.success(`  git commit -m "${message}"`);
+		}
+
+		if (this.shouldTag(context)) {
+			const name = `${git.tagPrefix}${context.version}`;
+			const message = git.tagMessage.replace("{version}", context.version);
+
+			const result = this.gitManager.tag(name, message);
+
+			context.git.tag = result.success;
+			context.git.tagName = result.success ? name : null;
+
+			if (result.success) {
+				logger.success(`  git tag ${name}`);
+			} else {
+				logger.warn(`  tag ignorada (${result.reason})`);
+			}
+		}
+
+		if (this.shouldPush(context)) {
+			const result = this.gitManager.push();
+
+			context.git.push = result.success;
+
+			if (result.success) {
+				logger.success("  git push");
+			} else {
+				logger.warn(`  push ignorado (${result.reason})`);
+			}
+
+			if (context.git.tag && result.success) {
+				this.gitManager.pushTags();
+				logger.success("  git push --tags");
+			}
+		}
+	}
+
+	finish(context) {
+		context.finishedAt = new Date();
+
+		const duration = context.finishedAt - context.startedAt;
+
+		this.fileManager.clearBackups();
+
+		logger.title(context.dryRun ? "Simulação concluída" : "Release concluída");
+
+		logger.field("Versão", `${context.previousVersion} → ${context.version}`);
+		logger.field("Arquivos", String(context.files.length));
+
+		if (context.git.branch) {
+			logger.field("Branch", context.git.branch);
+		}
+
+		logger.field("Git add", this.mark(context.git.add));
+		logger.field("Git commit", this.mark(context.git.commit));
+		logger.field("Git push", this.mark(context.git.push));
+
+		if (context.git.tagName) {
+			logger.field("Tag", context.git.tagName);
+		}
+
+		logger.field("Tempo", formatDuration(duration));
+
+		logger.break();
+	}
+
+	// ── Suporte ───────────────────────────────────────────────
+
+	rollback(context, error) {
+		logger.break();
+		logger.error(error.message);
+
+		const restoredFiles = this.fileManager.rollback();
+
+		const restoredVersion =
+			!context.dryRun && this.versionManager && context.previous?.build !== null
+				? this.versionManager.rollback(context.previous)
+				: false;
+
+		if (restoredFiles || restoredVersion) {
+			logger.warn("Alterações revertidas. Nada foi commitado.");
+		}
+
+		if (process.env.VERSIONER_DEBUG) {
+			console.error(error);
+		}
+	}
+
+	buildCommitMessage(context) {
+		return context.config.commit.template
+			.replace("{version}", context.version)
+			.replace("{message}", context.message)
+			.replace("{type}", context.type);
+	}
+
+	useGit(context) {
+		if (hasFlag(context.flags, "no-git")) {
+			return false;
+		}
+
+		return context.config ? context.config.git.enabled !== false : true;
+	}
+
+	shouldPush(context) {
+		if (hasFlag(context.flags, "no-push")) {
+			return false;
+		}
+
+		return context.config.git.push !== false;
+	}
+
+	shouldTag(context) {
+		if (hasFlag(context.flags, "tag")) {
+			return true;
+		}
+
+		if (hasFlag(context.flags, "no-tag")) {
+			return false;
+		}
+
+		return context.config.git.tag === true;
+	}
+
+	mark(value) {
+		return value ? "✔" : "✖";
+	}
+}
+
+module.exports = ReleaseManager;

package/src/managers/VersionManager.js

@@ -0,0 +1,126 @@
+const { resolve, exists, readJSON, writeJSON } = require("../utils/file");
+const { VERSION_FILE, DEFAULT_VERSION, VERSION_TYPES } = require("../constants");
+
+class VersionManager {
+	constructor(cwd = process.cwd(), versionFile = VERSION_FILE) {
+		this.cwd = cwd;
+		this.file = resolve(cwd, versionFile || VERSION_FILE);
+	}
+
+	exists() {
+		return exists(this.file);
+	}
+
+	/**
+	 * Lê o arquivo de versão. Cria com os valores padrão se não existir.
+	 */
+	load() {
+		if (!this.exists()) {
+			this.save(DEFAULT_VERSION);
+
+			return { ...DEFAULT_VERSION };
+		}
+
+		const version = readJSON(this.file);
+
+		return this.normalize(version);
+	}
+
+	/**
+	 * Garante que major/minor/build existam e sejam números inteiros.
+	 */
+	normalize(version) {
+		const result = { ...DEFAULT_VERSION };
+
+		for (const key of Object.keys(DEFAULT_VERSION)) {
+			const value = Number(version?.[key]);
+
+			if (!Number.isInteger(value) || value < 0) {
+				throw new Error(
+					`Valor inválido para "${key}" no arquivo de versão. Esperado um inteiro >= 0.`,
+				);
+			}
+
+			result[key] = value;
+		}
+
+		return result;
+	}
+
+	save(version) {
+		writeJSON(this.file, {
+			major: version.major,
+			minor: version.minor,
+			build: version.build,
+		});
+
+		return this.file;
+	}
+
+	toString(version) {
+		return `${version.major}.${version.minor}.${version.build}`;
+	}
+
+	/**
+	 * Calcula a próxima versão sem gravar nada.
+	 */
+	next(type, version) {
+		if (!VERSION_TYPES.includes(type)) {
+			throw new Error(
+				`Tipo de versão inválido: "${type}". Utilize build, minor ou major.`,
+			);
+		}
+
+		const result = { ...version };
+
+		// A Build sempre incrementa. Ela nunca volta para zero.
+		result.build += 1;
+
+		if (type === "minor") {
+			result.minor += 1;
+		}
+
+		if (type === "major") {
+			result.major += 1;
+			result.minor = 0;
+		}
+
+		return result;
+	}
+
+	/**
+	 * Incrementa e persiste (a menos que dryRun seja true).
+	 */
+	increment(type, { dryRun = false } = {}) {
+		const previous = this.load();
+
+		const current = this.next(type, previous);
+
+		if (!dryRun) {
+			this.save(current);
+		}
+
+		return {
+			previous,
+			current,
+			previousVersion: this.toString(previous),
+			version: this.toString(current),
+		};
+	}
+
+	/**
+	 * Volta o arquivo de versão para um estado anterior.
+	 * Usado quando o Git falha no meio da release.
+	 */
+	rollback(version) {
+		if (!version) {
+			return false;
+		}
+
+		this.save(version);
+
+		return true;
+	}
+}
+
+module.exports = VersionManager;

package/src/services/CommandRouter.js

@@ -0,0 +1,107 @@
+const BuildCommand = require("../commands/BuildCommand");
+const MinorCommand = require("../commands/MinorCommand");
+const MajorCommand = require("../commands/MajorCommand");
+const InitCommand = require("../commands/InitCommand");
+const HelpCommand = require("../commands/HelpCommand");
+const VersionCommand = require("../commands/VersionCommand");
+const StatusCommand = require("../commands/StatusCommand");
+
+const logger = require("../utils/logger");
+const { ALIASES } = require("../constants");
+
+/**
+ * Despacha o comando digitado na CLI.
+ * Sem switch: usa um mapa nome → classe.
+ */
+class CommandRouter {
+	constructor() {
+		this.commands = {
+			build: BuildCommand,
+			minor: MinorCommand,
+			major: MajorCommand,
+			init: InitCommand,
+			help: HelpCommand,
+			version: VersionCommand,
+			status: StatusCommand,
+		};
+	}
+
+	resolve(name) {
+		if (!name) {
+			return null;
+		}
+
+		return this.commands[ALIASES[name] || name] || null;
+	}
+
+	async run(args = []) {
+		const [name, ...rest] = args;
+
+		// Sem argumentos: mostra a ajuda.
+		if (!name) {
+			return new HelpCommand().run([]);
+		}
+
+		const Command = this.resolve(name);
+
+		if (!Command) {
+			logger.error(`Comando desconhecido: ${name}`);
+
+			const suggestion = this.suggest(name);
+
+			if (suggestion) {
+				logger.muted(`  Você quis dizer "${suggestion}"?`);
+			}
+
+			logger.muted('  Use "versioner help" para ver a lista de comandos.');
+			logger.break();
+
+			return 1;
+		}
+
+		return new Command().run(rest);
+	}
+
+	/**
+	 * Sugestão simples por distância de Levenshtein.
+	 */
+	suggest(name) {
+		let best = null;
+		let bestDistance = Infinity;
+
+		for (const command of Object.keys(this.commands)) {
+			const distance = this.distance(name.toLowerCase(), command);
+
+			if (distance < bestDistance) {
+				bestDistance = distance;
+				best = command;
+			}
+		}
+
+		return bestDistance <= 2 ? best : null;
+	}
+
+	distance(a, b) {
+		const matrix = Array.from({ length: a.length + 1 }, (_, i) => [i]);
+
+		for (let j = 0; j <= b.length; j += 1) {
+			matrix[0][j] = j;
+		}
+
+		for (let i = 1; i <= a.length; i += 1) {
+			for (let j = 1; j <= b.length; j += 1) {
+				const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+
+				matrix[i][j] = Math.min(
+					matrix[i - 1][j] + 1,
+					matrix[i][j - 1] + 1,
+					matrix[i - 1][j - 1] + cost,
+				);
+			}
+		}
+
+		return matrix[a.length][b.length];
+	}
+}
+
+module.exports = CommandRouter;