@carlos-iso/versioner 0.0.2

package/src/commands/MinorCommand.js

@@ -0,0 +1,9 @@
+const BaseCommand = require("./BaseCommand");
+
+class MinorCommand extends BaseCommand {
+	get type() {
+		return "minor";
+	}
+}
+
+module.exports = MinorCommand;

package/src/commands/StatusCommand.js

@@ -0,0 +1,118 @@
+const VersionManager = require("../managers/VersionManager");
+const ConfigManager = require("../managers/ConfigManager");
+const GitManager = require("../managers/GitManager");
+
+const logger = require("../utils/logger");
+const { resolve, exists, readJSON } = require("../utils/file");
+const { getValue } = require("../utils/object");
+const { CONFIG_FILE } = require("../constants");
+
+class StatusCommand {
+	async run() {
+		const cwd = process.cwd();
+
+		const configManager = new ConfigManager(cwd);
+		const gitManager = new GitManager(cwd);
+
+		logger.title("Versioner · status");
+
+		if (!configManager.exists()) {
+			logger.error(`${CONFIG_FILE} não encontrado. Execute "versioner init".`);
+			return 1;
+		}
+
+		const config = configManager.load();
+
+		const versionManager = new VersionManager(cwd, config.versionFile);
+
+		// ── Versão ────────────────────────────────────────────
+		logger.section("Versão");
+
+		if (versionManager.exists()) {
+			const version = versionManager.load();
+
+			logger.field("Atual", logger.bold(versionManager.toString(version)));
+			logger.field("Arquivo", config.versionFile);
+		} else {
+			logger.warn("Arquivo de versão ainda não criado.");
+		}
+
+		// ── Arquivos monitorados ──────────────────────────────
+		logger.section("Arquivos monitorados");
+
+		if (!config.files.length) {
+			logger.muted("  Nenhum arquivo configurado.");
+		}
+
+		for (const file of config.files) {
+			const filepath = resolve(cwd, file.path);
+
+			if (!exists(filepath)) {
+				logger.item(`${file.path} ${logger.dim("(não encontrado)")}`);
+				continue;
+			}
+
+			let current = "?";
+
+			try {
+				current = String(getValue(readJSON(filepath), file.field) ?? "não definido");
+			} catch {
+				current = "erro ao ler";
+			}
+
+			logger.item(`${file.path} ${logger.dim(`(${file.field} = ${current})`)}`);
+		}
+
+		// ── Configuração ──────────────────────────────────────
+		logger.section("Configuração");
+
+		logger.field("Commit", config.commit.template);
+		logger.field("Mensagem", `${config.commit.minLength}–${config.commit.maxLength} caracteres`);
+		logger.field("Git", config.git.enabled === false ? "desativado" : "ativado");
+		logger.field("Push automático", config.git.push ? "sim" : "não");
+		logger.field("Tag automática", config.git.tag ? `sim (${config.git.tagPrefix})` : "não");
+
+		// ── Git ───────────────────────────────────────────────
+		logger.section("Git");
+
+		if (!gitManager.isInstalled()) {
+			logger.warn("Git não encontrado no sistema.");
+			logger.break();
+			return 0;
+		}
+
+		if (!gitManager.isRepository()) {
+			logger.warn("Este diretório não é um repositório Git.");
+			logger.break();
+			return 0;
+		}
+
+		const changes = gitManager.changes();
+
+		logger.field("Branch", gitManager.branch() || "desconhecida");
+		logger.field("Remoto", gitManager.hasRemote() ? "configurado" : "nenhum");
+		logger.field("Upstream", gitManager.hasUpstream() ? "sim" : "não");
+		logger.field("Alterações", changes.length ? `${changes.length} arquivo(s)` : "nenhuma");
+
+		const last = gitManager.lastCommit();
+
+		if (last) {
+			logger.field("Último commit", last);
+		}
+
+		if (changes.length) {
+			logger.break();
+			changes.slice(0, 10).forEach((line) => logger.muted(`    ${line}`));
+
+			if (changes.length > 10) {
+				logger.muted(`    ... e mais ${changes.length - 10}`);
+			}
+		}
+
+		logger.break();
+
+		return 0;
+	}
+}
+
+module.exports = StatusCommand;

package/src/commands/VersionCommand.js

@@ -0,0 +1,63 @@
+const path = require("path");
+
+const VersionManager = require("../managers/VersionManager");
+const ConfigManager = require("../managers/ConfigManager");
+
+const logger = require("../utils/logger");
+const { readJSON } = require("../utils/file");
+const { parse, hasFlag } = require("../utils/args");
+const { VERSION_FILE } = require("../constants");
+
+class VersionCommand {
+	async run(args = []) {
+		const { flags } = parse(args);
+
+		// Versão do próprio Versioner
+		if (hasFlag(flags, "self")) {
+			const pkg = readJSON(path.join(__dirname, "..", "..", "package.json"));
+
+			console.log(pkg.version);
+
+			return 0;
+		}
+
+		const cwd = process.cwd();
+
+		const configManager = new ConfigManager(cwd);
+
+		const versionFile = configManager.exists()
+			? configManager.load().versionFile
+			: VERSION_FILE;
+
+		const versionManager = new VersionManager(cwd, versionFile);
+
+		if (!versionManager.exists()) {
+			logger.error('Projeto não inicializado. Execute "versioner init".');
+			return 1;
+		}
+
+		const version = versionManager.load();
+		const text = versionManager.toString(version);
+
+		if (hasFlag(flags, "json")) {
+			console.log(JSON.stringify({ ...version, version: text }, null, 2));
+			return 0;
+		}
+
+		if (hasFlag(flags, "raw")) {
+			console.log(text);
+			return 0;
+		}
+
+		logger.title("Versioner · version");
+		logger.field("Versão", logger.bold(text));
+		logger.field("Major", String(version.major));
+		logger.field("Minor", String(version.minor));
+		logger.field("Build", String(version.build));
+		logger.break();
+
+		return 0;
+	}
+}
+
+module.exports = VersionCommand;

package/src/constants/index.js

@@ -0,0 +1,150 @@
+/**
+ * Constantes globais do Versioner.
+ * Nenhuma regra de negócio aqui, apenas valores fixos.
+ */
+
+const VERSION_FILE = ".versioner.json";
+
+const CONFIG_FILE = "versioner.config.json";
+
+const VERSION_TYPES = ["build", "minor", "major"];
+
+const DEFAULT_VERSION = {
+	major: 0,
+	minor: 0,
+	build: 0,
+};
+
+const DEFAULT_COMMIT = {
+	template: "v{version} - {message}",
+	minLength: 3,
+	maxLength: 100,
+};
+
+const DEFAULT_GIT = {
+	enabled: true,
+	add: true,
+	commit: true,
+	push: true,
+	tag: false,
+	tagPrefix: "v",
+	tagMessage: "Release {version}",
+};
+
+const DEFAULT_CONFIG = {
+	versionFile: VERSION_FILE,
+	files: [],
+	commit: DEFAULT_COMMIT,
+	git: DEFAULT_GIT,
+};
+
+/**
+ * Arquivos que o `init` tenta detectar automaticamente.
+ * `json: false` significa que o arquivo é código e não pode ser
+ * versionado automaticamente (apenas avisamos o usuário).
+ */
+const DETECTABLE_FILES = [
+	{ path: "package.json", field: "version", json: true },
+	{ path: "app.json", field: "expo.version", json: true },
+	{ path: "manifest.json", field: "version", json: true },
+	{ path: "app.config.js", json: false },
+	{ path: "app.config.ts", json: false },
+];
+
+/**
+ * Metadados usados pelo HelpCommand e pelo CommandRouter.
+ */
+const COMMANDS = [
+	{
+		name: "init",
+		usage: "versioner init [--yes] [--force]",
+		summary: "Inicializa o Versioner no projeto atual.",
+		details: [
+			"Verifica se existe um repositório Git.",
+			`Cria o ${VERSION_FILE} (contador de versão).`,
+			`Cria o ${CONFIG_FILE} (arquivos monitorados).`,
+			"Detecta package.json, app.json, app.config.js e app.config.ts.",
+			"Pergunta a versão inicial do projeto.",
+			"",
+			"Flags:",
+			"  --yes, -y     Usa os valores padrão sem perguntar nada.",
+			"  --force, -f   Sobrescreve arquivos já existentes.",
+		],
+	},
+	{
+		name: "build",
+		usage: 'versioner build "mensagem do commit"',
+		summary: "Incrementa a Build e publica a release.",
+		details: [
+			"Exemplo: 1.4.272 → 1.4.273",
+			"",
+			"Flags:",
+			"  --no-push     Faz commit mas não envia para o remoto.",
+			"  --no-git      Apenas versiona os arquivos, sem tocar no Git.",
+			"  --tag         Cria uma tag Git para essa release.",
+			"  --dry-run     Simula tudo sem gravar nada.",
+		],
+	},
+	{
+		name: "minor",
+		usage: 'versioner minor "mensagem do commit"',
+		summary: "Incrementa Minor e Build e publica a release.",
+		details: ["Exemplo: 1.4.272 → 1.5.273", "", "Aceita as mesmas flags do build."],
+	},
+	{
+		name: "major",
+		usage: 'versioner major "mensagem do commit"',
+		summary: "Incrementa Major, zera Minor, incrementa Build.",
+		details: ["Exemplo: 1.4.272 → 2.0.273", "", "Aceita as mesmas flags do build."],
+	},
+	{
+		name: "version",
+		usage: "versioner version [--json]",
+		summary: "Mostra a versão atual do projeto.",
+		details: [
+			"Flags:",
+			"  --json        Retorna a versão em JSON.",
+			"  --raw         Retorna apenas a string da versão.",
+			"  --self        Mostra a versão do próprio Versioner.",
+		],
+	},
+	{
+		name: "status",
+		usage: "versioner status",
+		summary: "Mostra versão, arquivos monitorados e estado do Git.",
+		details: [],
+	},
+	{
+		name: "help",
+		usage: "versioner help [comando]",
+		summary: "Lista os comandos disponíveis.",
+		details: [],
+	},
+];
+
+const ALIASES = {
+	b: "build",
+	m: "minor",
+	M: "major",
+	i: "init",
+	h: "help",
+	v: "version",
+	s: "status",
+	"--help": "help",
+	"-h": "help",
+	"--version": "version",
+	"-v": "version",
+};
+
+module.exports = {
+	VERSION_FILE,
+	CONFIG_FILE,
+	VERSION_TYPES,
+	DEFAULT_VERSION,
+	DEFAULT_COMMIT,
+	DEFAULT_GIT,
+	DEFAULT_CONFIG,
+	DETECTABLE_FILES,
+	COMMANDS,
+	ALIASES,
+};

package/src/core/Context.js

@@ -0,0 +1,65 @@
+/**
+ * Objeto compartilhado por toda a execução.
+ *
+ * Regra da arquitetura: nenhum Manager conhece outro Manager.
+ * Todos leem e escrevem apenas no Context.
+ */
+function createContext({ type, message = "", cwd = process.cwd(), flags = {} } = {}) {
+	return {
+		// Argumentos da CLI
+		type,
+		message,
+		flags,
+
+		// Diretório onde a ferramenta foi executada
+		cwd,
+
+		// Configuração do projeto (versioner.config.json)
+		config: null,
+
+		// Versão anterior (string)
+		previousVersion: null,
+
+		// Versão atual (string)
+		version: null,
+
+		// Objeto da versão anterior
+		previous: {
+			major: null,
+			minor: null,
+			build: null,
+		},
+
+		// Objeto da versão atual
+		current: {
+			major: null,
+			minor: null,
+			build: null,
+		},
+
+		// Arquivos atualizados durante a release
+		files: [],
+
+		// Arquivos configurados que não foram encontrados
+		skipped: [],
+
+		// Informações do Git
+		git: {
+			add: false,
+			commit: false,
+			push: false,
+			tag: false,
+			tagName: null,
+			branch: null,
+		},
+
+		// Modo simulação
+		dryRun: false,
+
+		// Controle de execução
+		startedAt: new Date(),
+		finishedAt: null,
+	};
+}
+
+module.exports = { createContext };

package/src/index.js

@@ -0,0 +1,28 @@
+/**
+ * Entrada programática do Versioner.
+ *
+ * const { ReleaseManager, createContext } = require("@carloscoding/versioner");
+ */
+
+const ReleaseManager = require("./managers/ReleaseManager");
+const VersionManager = require("./managers/VersionManager");
+const ConfigManager = require("./managers/ConfigManager");
+const FileManager = require("./managers/FileManager");
+const GitManager = require("./managers/GitManager");
+const CommandRouter = require("./services/CommandRouter");
+
+const { createContext } = require("./core/Context");
+const logger = require("./utils/logger");
+const constants = require("./constants");
+
+module.exports = {
+	ReleaseManager,
+	VersionManager,
+	ConfigManager,
+	FileManager,
+	GitManager,
+	CommandRouter,
+	createContext,
+	logger,
+	constants,
+};

package/src/managers/ConfigManager.js

@@ -0,0 +1,70 @@
+const { resolve, exists, readJSON, writeJSON } = require("../utils/file");
+const { merge } = require("../utils/object");
+const { CONFIG_FILE, DEFAULT_CONFIG } = require("../constants");
+
+class ConfigManager {
+	constructor(cwd = process.cwd()) {
+		this.cwd = cwd;
+		this.file = resolve(cwd, CONFIG_FILE);
+	}
+
+	exists() {
+		return exists(this.file);
+	}
+
+	/**
+	 * Carrega a configuração, aplica os defaults e valida o formato.
+	 */
+	load() {
+		if (!this.exists()) {
+			throw new Error(
+				`Arquivo ${CONFIG_FILE} não encontrado. Execute "versioner init" neste projeto.`,
+			);
+		}
+
+		const raw = readJSON(this.file);
+
+		const config = merge(DEFAULT_CONFIG, raw);
+
+		this.validate(config);
+
+		return config;
+	}
+
+	validate(config) {
+		if (!Array.isArray(config.files)) {
+			throw new Error(`"files" deve ser um array em ${CONFIG_FILE}.`);
+		}
+
+		config.files.forEach((file, index) => {
+			if (!file || typeof file !== "object") {
+				throw new Error(`files[${index}] deve ser um objeto em ${CONFIG_FILE}.`);
+			}
+
+			if (!file.path) {
+				throw new Error(`files[${index}] está sem a propriedade "path".`);
+			}
+
+			if (!file.field) {
+				throw new Error(`files[${index}] (${file.path}) está sem a propriedade "field".`);
+			}
+		});
+
+		if (!config.versionFile) {
+			throw new Error(`"versionFile" não pode ser vazio em ${CONFIG_FILE}.`);
+		}
+
+		return true;
+	}
+
+	/**
+	 * Cria/sobrescreve o arquivo de configuração.
+	 */
+	save(config) {
+		writeJSON(this.file, config);
+
+		return this.file;
+	}
+}
+
+module.exports = ConfigManager;

package/src/managers/FileManager.js

@@ -0,0 +1,75 @@
+const { resolve, exists, readJSON, writeJSON, readText, writeText } = require("../utils/file");
+const { setValue, getValue } = require("../utils/object");
+
+class FileManager {
+	constructor(cwd = process.cwd()) {
+		this.cwd = cwd;
+
+		// Guarda o conteúdo original para permitir rollback.
+		this.backups = [];
+	}
+
+	/**
+	 * Atualiza a versão dentro de um arquivo JSON.
+	 *
+	 * @returns {{ updated: boolean, reason?: string, from?: string }}
+	 */
+	update(file, version, { dryRun = false } = {}) {
+		const filepath = resolve(this.cwd, file.path);
+
+		if (!exists(filepath)) {
+			return { updated: false, reason: "arquivo não encontrado" };
+		}
+
+		if (!filepath.endsWith(".json")) {
+			return { updated: false, reason: "apenas arquivos .json são suportados" };
+		}
+
+		const json = readJSON(filepath);
+
+		const from = getValue(json, file.field);
+
+		if (from === version) {
+			return { updated: false, reason: "já está na versão atual", from };
+		}
+
+		if (dryRun) {
+			return { updated: true, from, dryRun: true };
+		}
+
+		this.backups.push({ filepath, content: readText(filepath) });
+
+		setValue(json, file.field, version);
+
+		writeJSON(filepath, json);
+
+		return { updated: true, from };
+	}
+
+	/**
+	 * Restaura todos os arquivos alterados nesta execução.
+	 */
+	rollback() {
+		let restored = 0;
+
+		while (this.backups.length) {
+			const backup = this.backups.pop();
+
+			try {
+				writeText(backup.filepath, backup.content);
+				restored += 1;
+			} catch {
+				// Um arquivo que não pode ser restaurado não deve
+				// impedir a restauração dos demais.
+			}
+		}
+
+		return restored;
+	}
+
+	clearBackups() {
+		this.backups = [];
+	}
+}
+
+module.exports = FileManager;