@carlos-iso/versioner 0.0.2

package/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2026 <copyright holders>
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.

package/README.md

@@ -0,0 +1,290 @@
+# Versioner
+
+CLI que substitui o fluxo manual de release por um único comando.
+
+Antes:
+
+```bash
+# edita package.json
+# edita app.json
+git add .
+git commit -m "v1.4.273 - Corrige login"
+git push
+```
+
+Depois:
+
+```bash
+versioner build "Corrige login"
+```
+
+Sem dependências externas. Só Node.js e Git.
+
+---
+
+## Instalação
+
+No projeto:
+
+```bash
+npm install -D @carloscoding/versioner
+```
+
+Sem instalar:
+
+```bash
+npx @carloscoding/versioner init
+```
+
+Global:
+
+```bash
+npm install -g @carloscoding/versioner
+```
+
+Requer Node.js 16 ou superior.
+
+---
+
+## Início rápido
+
+```bash
+cd meu-projeto
+npx @carloscoding/versioner init
+npx versioner build "primeira release"
+```
+
+O `init` cria dois arquivos, detecta o `package.json` e o `app.json`, e pergunta a versão inicial.
+
+Se estiver usando como dependência do projeto, adicione atalhos no `package.json`:
+
+```json
+{
+    "scripts": {
+        "build": "versioner build",
+        "minor": "versioner minor",
+        "major": "versioner major"
+    }
+}
+```
+
+E use:
+
+```bash
+npm run build -- "Corrige login"
+```
+
+---
+
+## Modelo de versionamento
+
+Formato:
+
+```
+major.minor.build
+```
+
+Exemplo: `2.14.583`
+
+### Build
+
+Incrementa em **toda** release e **nunca** volta para zero. Representa o total de releases já publicadas.
+
+```
+2.14.583 → 2.14.584 → 2.14.585
+```
+
+### Minor
+
+Pequenas evoluções dentro de uma mesma versão principal. Zera quando ocorre um Major.
+
+```
+2.14.583 → 2.15.584
+```
+
+### Major
+
+Grandes marcos: primeira versão pública, reescrita, nova arquitetura. Definido manualmente.
+
+```
+2.14.583 → 3.0.584
+```
+
+O Build continua incrementando normalmente mesmo em um Major.
+
+### Por que não SemVer
+
+O SemVer descreve compatibilidade de API. Este modelo descreve o **histórico do projeto**: quantas grandes versões existiram, quantas evoluções cada uma recebeu e quantas releases foram publicadas desde o início.
+
+O formato continua compatível com `x.y.z`, então o `package.json` permanece válido.
+
+---
+
+## Comandos
+
+| Comando | O que faz |
+|---|---|
+| `versioner init` | Inicializa o Versioner no projeto |
+| `versioner build "msg"` | Incrementa a Build e publica a release |
+| `versioner minor "msg"` | Incrementa Minor e Build |
+| `versioner major "msg"` | Incrementa Major, zera Minor, incrementa Build |
+| `versioner version` | Mostra a versão atual |
+| `versioner status` | Mostra versão, arquivos monitorados e estado do Git |
+| `versioner help [comando]` | Ajuda |
+
+Aliases: `b`, `m`, `M`, `i`, `v`, `s`, `h`.
+
+### Flags de release
+
+| Flag | Efeito |
+|---|---|
+| `--no-push` | Faz commit mas não envia para o remoto |
+| `--no-git` | Só versiona os arquivos, não toca no Git |
+| `--tag` | Cria uma tag Git para a release |
+| `--no-tag` | Desativa a tag mesmo se ligada na config |
+| `--dry-run` | Simula tudo sem gravar nada |
+
+### Flags do init
+
+| Flag | Efeito |
+|---|---|
+| `--yes`, `-y` | Usa os padrões sem perguntar |
+| `--force`, `-f` | Sobrescreve arquivos existentes |
+
+---
+
+## Arquivos gerados
+
+### `.versioner.json`
+
+O contador de versão do projeto.
+
+```json
+{
+    "major": 1,
+    "minor": 4,
+    "build": 273
+}
+```
+
+### `versioner.config.json`
+
+Define o comportamento e quais arquivos recebem a versão.
+
+```json
+{
+    "versionFile": ".versioner.json",
+    "files": [
+        {
+            "path": "package.json",
+            "field": "version"
+        },
+        {
+            "path": "app.json",
+            "field": "expo.version"
+        }
+    ],
+    "commit": {
+        "template": "v{version} - {message}",
+        "minLength": 3,
+        "maxLength": 100
+    },
+    "git": {
+        "enabled": true,
+        "add": true,
+        "commit": true,
+        "push": true,
+        "tag": false,
+        "tagPrefix": "v",
+        "tagMessage": "Release {version}"
+    }
+}
+```
+
+**`files`** — qualquer arquivo `.json`. O campo `field` aceita caminhos aninhados:
+
+```
+version
+expo.version
+project.meta.version
+```
+
+**`commit.template`** — aceita `{version}`, `{message}` e `{type}`.
+
+Arquivos de código (`app.config.js`, `app.config.ts`) são detectados pelo `init` mas **não** são alterados automaticamente. Nesses casos, leia a versão do JSON:
+
+```js
+const { version } = require("./package.json");
+
+export default {
+    expo: { version },
+};
+```
+
+---
+
+## Segurança da release
+
+Se qualquer etapa falhar no meio do caminho, o Versioner reverte o arquivo de versão e todos os arquivos alterados. Nada fica commitado pela metade.
+
+O `push` é ignorado com um aviso quando não existe remoto configurado, em vez de derrubar a release. Se a branch ainda não tiver upstream, o Versioner usa `--set-upstream origin <branch>` automaticamente.
+
+Mensagens de commit são passadas por `execFile` com array de argumentos, então aspas, `$` e crases não quebram nem executam nada.
+
+---
+
+## Uso programático
+
+```js
+const { ReleaseManager, createContext } = require("@carloscoding/versioner");
+
+const context = createContext({ type: "build", message: "Release automática" });
+
+new ReleaseManager().run(context);
+```
+
+Também são exportados `VersionManager`, `ConfigManager`, `FileManager`, `GitManager`, `CommandRouter`, `logger` e `constants`.
+
+---
+
+## Arquitetura
+
+```
+bin/versioner.js         Binário da CLI (shebang)
+src/cli.js               Bootstrap da CLI e tratamento de erro
+src/index.js             Entrada programática (require do pacote)
+src/services/            CommandRouter (mapa nome → classe)
+src/commands/            Um arquivo por comando
+src/managers/            Release, Version, Config, File, Git
+src/core/Context.js      Objeto compartilhado da execução
+src/utils/               file, object, time, args, logger
+src/constants/           Valores fixos e metadados de ajuda
+```
+
+Regra central: nenhum Manager conhece outro Manager. Todos leem e escrevem apenas no `Context`. O `ReleaseManager` só orquestra a sequência:
+
+```
+validate → loadConfig → version → updateFiles → git → finish
+```
+
+---
+
+## Desenvolvimento
+
+```bash
+npm test    # teste de fumaça em um repositório Git temporário
+```
+
+Para logs completos de erro:
+
+```bash
+VERSIONER_DEBUG=1 versioner build "teste"
+```
+
+Cores são desativadas automaticamente com `NO_COLOR=1` ou fora de um TTY.
+
+---
+
+## Licença
+
+MIT.

package/bin/versioner.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+require("../src/cli");

package/package.json

@@ -0,0 +1,50 @@
+{
+	"name": "@carlos-iso/versioner",
+	"version": "0.0.2",
+	"description": "CLI para automatizar versionamento e fluxo de Git usando um modelo de versionamento baseado em marcos do projeto (major.minor.build).",
+	"license": "MIT",
+	"author": "Carlos-iso",
+	"type": "commonjs",
+	"main": "src/index.js",
+	"bin": {
+		"versioner": "bin/versioner.js"
+	},
+	"files": [
+		"bin",
+		"src",
+		"README.md",
+		"LICENSE"
+	],
+	"engines": {
+		"node": ">=18"
+	},
+	"scripts": {
+		"start": "node ./bin/versioner.js",
+		"dev": "node ./bin/versioner.js",
+		"help": "node ./bin/versioner.js help",
+		"test": "node ./test/smoke.js",
+		"prepublishOnly": "node ./src/test/smoke.js"
+	},
+	"keywords": [
+		"version",
+		"versioning",
+		"release",
+		"git",
+		"automation",
+		"cli",
+		"build",
+		"semver",
+		"expo"
+	],
+	"publishConfig": {
+		"access": "public"
+	},
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/Carlos-iso/versioner.git"
+	},
+	"homepage": "https://github.com/Carlos-iso/versioner",
+	"bugs": {
+		"url": "https://github.com/Carlos-iso/versioner/issues"
+	}
+}

package/src/cli.js

@@ -0,0 +1,21 @@
+const CommandRouter = require("./services/CommandRouter");
+const logger = require("./utils/logger");
+
+async function main() {
+	const router = new CommandRouter();
+
+	const code = await router.run(process.argv.slice(2));
+
+	process.exit(code || 0);
+}
+
+main().catch((error) => {
+	logger.break();
+	logger.error(error.message);
+
+	if (process.env.VERSIONER_DEBUG) {
+		console.error(error);
+	}
+
+	process.exit(1);
+});

package/src/commands/BaseCommand.js

@@ -0,0 +1,33 @@
+const ReleaseManager = require("../managers/ReleaseManager");
+const { createContext } = require("../core/Context");
+const { parse, toMessage } = require("../utils/args");
+
+/**
+ * Base dos comandos de release (build, minor, major).
+ * Monta o Context e delega tudo ao ReleaseManager.
+ */
+class BaseCommand {
+	/**
+	 * Sobrescrito pelas subclasses: "build" | "minor" | "major".
+	 */
+	get type() {
+		throw new Error("Comando sem tipo definido.");
+	}
+
+	async run(args = []) {
+		const { values, flags } = parse(args);
+
+		const context = createContext({
+			type: this.type,
+			message: toMessage(values),
+			cwd: process.cwd(),
+			flags,
+		});
+
+		const release = new ReleaseManager(context.cwd);
+
+		return release.run(context);
+	}
+}
+
+module.exports = BaseCommand;

package/src/commands/BuildCommand.js

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

package/src/commands/HelpCommand.js

@@ -0,0 +1,77 @@
+const logger = require("../utils/logger");
+const { parse } = require("../utils/args");
+const { COMMANDS, ALIASES } = require("../constants");
+
+class HelpCommand {
+	async run(args = []) {
+		const { values } = parse(args);
+
+		const target = values[0];
+
+		if (target) {
+			return this.detail(ALIASES[target] || target);
+		}
+
+		return this.overview();
+	}
+
+	overview() {
+		logger.title("Versioner");
+
+		logger.muted("  Automatiza versionamento e fluxo de Git em um único comando.");
+
+		logger.section("Uso");
+		logger.muted("  versioner <comando> [argumentos] [flags]");
+
+		logger.section("Comandos");
+
+		const width = Math.max(...COMMANDS.map((command) => command.name.length)) + 4;
+
+		for (const command of COMMANDS) {
+			logger.write(`  ${logger.bold(command.name.padEnd(width))}${command.summary}`);
+		}
+
+		logger.section("Exemplos");
+		logger.muted("  versioner init");
+		logger.muted('  versioner build "Corrige o login"');
+		logger.muted('  versioner minor "Adiciona filtros na busca"');
+		logger.muted('  versioner major "Nova arquitetura" --tag');
+		logger.muted("  versioner status");
+
+		logger.section("Ajuda de um comando");
+		logger.muted("  versioner help build");
+		logger.break();
+
+		return 0;
+	}
+
+	detail(name) {
+		const command = COMMANDS.find((item) => item.name === name);
+
+		if (!command) {
+			logger.error(`Comando desconhecido: ${name}`);
+			logger.muted('  Use "versioner help" para ver a lista de comandos.');
+			logger.break();
+
+			return 1;
+		}
+
+		logger.title(`Versioner · ${command.name}`);
+
+		logger.muted(`  ${command.summary}`);
+
+		logger.section("Uso");
+		logger.muted(`  ${command.usage}`);
+
+		if (command.details.length) {
+			logger.section("Detalhes");
+			command.details.forEach((line) => logger.muted(`  ${line}`));
+		}
+
+		logger.break();
+
+		return 0;
+	}
+}
+
+module.exports = HelpCommand;

package/src/commands/InitCommand.js

@@ -0,0 +1,197 @@
+const readline = require("readline");
+
+const ConfigManager = require("../managers/ConfigManager");
+const VersionManager = require("../managers/VersionManager");
+const GitManager = require("../managers/GitManager");
+
+const logger = require("../utils/logger");
+const { resolve, exists, readJSON } = require("../utils/file");
+const { parse, hasFlag } = require("../utils/args");
+const {
+	CONFIG_FILE,
+	VERSION_FILE,
+	DEFAULT_CONFIG,
+	DEFAULT_VERSION,
+	DETECTABLE_FILES,
+} = require("../constants");
+
+class InitCommand {
+	async run(args = []) {
+		const { flags } = parse(args);
+
+		const cwd = process.cwd();
+
+		const auto = hasFlag(flags, "yes");
+		const force = hasFlag(flags, "force");
+
+		const configManager = new ConfigManager(cwd);
+		const versionManager = new VersionManager(cwd, VERSION_FILE);
+		const gitManager = new GitManager(cwd);
+
+		logger.title("Versioner · init");
+
+		// 1. Repositório Git
+		if (!gitManager.isInstalled()) {
+			logger.error("Git não encontrado no sistema.");
+			return 1;
+		}
+
+		if (!gitManager.isRepository()) {
+			logger.warn('Nenhum repositório Git encontrado. Rode "git init" antes de publicar.');
+		} else {
+			logger.success(`Repositório Git detectado (branch: ${gitManager.branch()}).`);
+		}
+
+		// 2. Arquivos já existentes
+		if ((configManager.exists() || versionManager.exists()) && !force) {
+			logger.error(
+				`O Versioner já está inicializado neste projeto. Use --force para sobrescrever.`,
+			);
+			return 1;
+		}
+
+		// 3. Detecção de arquivos
+		const detected = this.detect(cwd);
+
+		if (detected.supported.length) {
+			logger.success("Arquivos detectados:");
+			detected.supported.forEach((file) => logger.item(`${file.path} (${file.field})`));
+		} else {
+			logger.warn("Nenhum arquivo JSON de versão foi detectado.");
+		}
+
+		detected.unsupported.forEach((file) => {
+			logger.warn(
+				`${file.path} detectado, mas arquivos de código não são versionados automaticamente.`,
+			);
+		});
+
+		// 4. Versão inicial
+		const initial = auto
+			? this.fromPackage(cwd) || { ...DEFAULT_VERSION }
+			: await this.ask(cwd);
+
+		// 5. Gravação
+		const config = {
+			...DEFAULT_CONFIG,
+			versionFile: VERSION_FILE,
+			files: detected.supported.map((file) => ({
+				path: file.path,
+				field: file.field,
+			})),
+		};
+
+		configManager.save(config);
+		versionManager.save(initial);
+
+		logger.break();
+		logger.success(`${CONFIG_FILE} criado.`);
+		logger.success(`${VERSION_FILE} criado.`);
+
+		logger.section("Versão inicial");
+		logger.field("Versão", versionManager.toString(initial));
+
+		logger.section("Próximo passo");
+		logger.muted('  versioner build "primeira release"');
+		logger.break();
+
+		return 0;
+	}
+
+	/**
+	 * Procura arquivos conhecidos no diretório atual.
+	 */
+	detect(cwd) {
+		const supported = [];
+		const unsupported = [];
+
+		for (const file of DETECTABLE_FILES) {
+			if (!exists(resolve(cwd, file.path))) {
+				continue;
+			}
+
+			if (file.json) {
+				supported.push(file);
+			} else {
+				unsupported.push(file);
+			}
+		}
+
+		return { supported, unsupported };
+	}
+
+	/**
+	 * Tenta reaproveitar a versão já presente no package.json.
+	 */
+	fromPackage(cwd) {
+		const filepath = resolve(cwd, "package.json");
+
+		if (!exists(filepath)) {
+			return null;
+		}
+
+		try {
+			const version = readJSON(filepath).version;
+
+			return this.parseVersion(version);
+		} catch {
+			return null;
+		}
+	}
+
+	parseVersion(value) {
+		const match = String(value || "").match(/^(\d+)\.(\d+)\.(\d+)/);
+
+		if (!match) {
+			return null;
+		}
+
+		return {
+			major: Number(match[1]),
+			minor: Number(match[2]),
+			build: Number(match[3]),
+		};
+	}
+
+	/**
+	 * Pergunta interativa da versão inicial.
+	 */
+	async ask(cwd) {
+		const suggestion = this.fromPackage(cwd) || { ...DEFAULT_VERSION };
+
+		const suggested = `${suggestion.major}.${suggestion.minor}.${suggestion.build}`;
+
+		logger.break();
+
+		const answer = await this.prompt(`Versão inicial [${suggested}]: `);
+
+		if (!answer.trim()) {
+			return suggestion;
+		}
+
+		const parsed = this.parseVersion(answer.trim().replace(/^v/i, ""));
+
+		if (!parsed) {
+			logger.warn(`Formato inválido. Usando ${suggested}.`);
+			return suggestion;
+		}
+
+		return parsed;
+	}
+
+	prompt(question) {
+		const rl = readline.createInterface({
+			input: process.stdin,
+			output: process.stdout,
+		});
+
+		return new Promise((resolveAnswer) => {
+			rl.question(question, (answer) => {
+				rl.close();
+				resolveAnswer(answer);
+			});
+		});
+	}
+}
+
+module.exports = InitCommand;

package/src/commands/MajorCommand.js

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