@caioms/pre-git-auto-format 1.0.0

package/bin/setup.js

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+// ^ Garante que o script seja executado com Node.js
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const projectRoot = process.cwd(); // Diretório raiz do projeto consumidor
+
+function runCommand(command) {
+    try {
+        console.log(`Executando: ${command}`);
+        execSync(command, { stdio: 'inherit', cwd: projectRoot });
+        return true;
+    } catch (error) {
+        console.error(`Falha ao executar: ${command}`, error);
+        return false;
+    }
+}
+
+function fileExists(filePath) {
+    return fs.existsSync(path.join(projectRoot, filePath));
+}
+
+function writeJsonFile(filePath, data) {
+    fs.writeFileSync(path.join(projectRoot, filePath), JSON.stringify(data, null, 4));
+    console.log(`Arquivo criado/atualizado: ${filePath}`);
+}
+
+function main() {
+    console.log('Configurando hooks de pré-commit com @caioms/pre-git-auto-format...');
+
+    // Etapa 0: Verificar se as peerDependencies estão instaladas (informativo)
+    // Idealmente, o gerenciador de pacotes já cuidou disso ou emitiu avisos.
+    // Uma verificação mais robusta poderia tentar importar os módulos.
+    console.log('Verificando dependências peer necessárias (husky, lint-staged, @biomejs/biome, @caioms/biomejs-config)...');
+    // (Você pode adicionar uma lógica mais sofisticada aqui para verificar se os pacotes existem em node_modules)
+
+    // Etapa 1: Inicializar Husky (se não existir .husky)
+    if (!fileExists('.husky')) {
+        if (!runCommand('npx husky init')) {
+            console.error('Falha ao inicializar o Husky. Por favor, verifique se o Husky está instalado e tente novamente.');
+            process.exit(1);
+        }
+    } else {
+        console.log('.husky já existe, pulando inicialização.');
+    }
+
+    // Etapa 2: Adicionar/Atualizar o hook pre-commit do Husky
+    const preCommitHookPath = path.join('.husky', 'pre-commit');
+    const preCommitCommand = 'npx lint-staged';
+    // Poderíamos verificar se o comando já existe, mas para simplificar, vamos sobrescrever.
+    // Em uma versão mais avançada, você poderia tentar adicionar ao invés de sobrescrever.
+    console.log(`Configurando hook pre-commit para executar: "${preCommitCommand}"`);
+    fs.writeFileSync(path.join(projectRoot, preCommitHookPath), `#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+${preCommitCommand}
+`);
+    runCommand(`chmod +x ${preCommitHookPath}`); // Tornar executável
+    console.log(`Hook pre-commit configurado em: ${preCommitHookPath}`);
+
+
+    // Etapa 3: Criar/Atualizar o arquivo de configuração do lint-staged
+    const lintStagedConfig = {
+        "*.{js,jsx,ts,tsx,mjs,cjs}": ["npx biome format --write"],
+        // Você pode adicionar mais padrões aqui se desejar, por exemplo, para JSON, Markdown, etc.
+        // "*.{json,md}": ["npx biome format --write"]
+    };
+    // lint-staged suporta vários nomes de arquivo de configuração.
+    // .lintstagedrc.json é uma boa escolha.
+    writeJsonFile('.lintstagedrc.json', lintStagedConfig);
+
+
+    // Etapa 4: Garantir que o biome.json do projeto estenda o seu @caioms/biomejs-config
+    const biomeConfigPath = 'biome.json';
+    let projectBiomeConfig = {};
+
+    if (fileExists(biomeConfigPath)) {
+        try {
+            projectBiomeConfig = JSON.parse(fs.readFileSync(path.join(projectRoot, biomeConfigPath), 'utf-8'));
+        } catch (e) {
+            console.warn(`Aviso: Não foi possível ler o ${biomeConfigPath} existente. Ele será sobrescrito com a configuração base.`);
+            projectBiomeConfig = {};
+        }
+    }
+
+    const biomeExtendsValue = '@caioms/biomejs-config';
+    if (projectBiomeConfig.extends) {
+        if (Array.isArray(projectBiomeConfig.extends)) {
+            if (!projectBiomeConfig.extends.includes(biomeExtendsValue)) {
+                projectBiomeConfig.extends.push(biomeExtendsValue);
+            }
+        } else if (projectBiomeConfig.extends !== biomeExtendsValue) {
+            // Se extends é uma string e não é a nossa, transforma em array
+            projectBiomeConfig.extends = [projectBiomeConfig.extends, biomeExtendsValue];
+        }
+        // Se já for a string correta, não faz nada
+    } else {
+        projectBiomeConfig.extends = [biomeExtendsValue];
+    }
+
+    // Adiciona um $schema se não existir, para melhor autocompletar no editor
+    if (!projectBiomeConfig.$schema) {
+        projectBiomeConfig.$schema = "./node_modules/@biomejs/biome/configuration_schema.json";
+    }
+
+    writeJsonFile(biomeConfigPath, projectBiomeConfig);
+
+
+    // Etapa 5: (Opcional) Adicionar script "prepare" ao package.json do consumidor
+    // Isso é útil para Husky v7+ para instalar automaticamente os hooks após o `npm install`
+    try {
+        const packageJsonPath = path.join(projectRoot, 'package.json');
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+        if (!packageJson.scripts) {
+            packageJson.scripts = {};
+        }
+        if (packageJson.scripts.prepare !== 'husky' && packageJson.scripts.prepare !== 'husky install') { // Evita conflitos se já existir
+            // Se houver outro script prepare, avisa o usuário.
+            // Para simplificar, aqui vamos apenas adicionar se não existir ou for diferente.
+            // Uma solução mais robusta poderia tentar concatenar comandos.
+            if (packageJson.scripts.prepare) {
+                 console.warn(`Aviso: O projeto já possui um script "prepare": "${packageJson.scripts.prepare}". Não foi possível adicionar "husky" automaticamente. Considere adicionar "husky" ou "husky install" manualmente ao seu script "prepare".`);
+            } else {
+                packageJson.scripts.prepare = 'husky'; // Para Husky v9+
+                // ou 'husky install' para Husky v7/v8
+                // Detectar a versão do Husky instalada pode ser mais robusto aqui.
+                // Por simplicidade, vamos usar 'husky' assumindo v9+.
+                fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+                console.log('Script "prepare": "husky" adicionado/atualizado no package.json.');
+            }
+        }
+    } catch (error) {
+        console.warn('Não foi possível modificar o package.json para adicionar o script "prepare".', error);
+    }
+
+    console.log('\nConfiguração concluída com sucesso!');
+    console.log('Certifique-se de que as seguintes dependências estão instaladas no seu projeto:');
+    console.log('  npm install --save-dev husky lint-staged @biomejs/biome @caioms/biomejs-config');
+    console.log('  (ou use pnpm/yarn)');
+    console.log('\nPróximos passos:');
+    console.log('1. Adicione arquivos ao git stage (git add .).');
+    console.log('2. Tente fazer um commit (git commit -m "test").');
+    console.log('O Biome deve formatar seus arquivos automaticamente antes do commit.');
+}
+
+main();

package/package.json

@@ -0,0 +1,16 @@
+{
+    "name": "@caioms/pre-git-auto-format",
+    "version": "1.0.0",
+    "license": "MIT",
+    "main": "biome.json",
+    "private": false,
+    "bin": {
+        "setup-caioms-hooks": "./bin/setup.js"
+    },
+    "files": ["bin/"],
+    "peerDependencies": {
+        "husky": "^9.1.6",
+        "lint-staged": "^12.3.2",
+        "@caioms/biomejs-config": "^1.0.0"
+    }
+}