specifica-br 1.0.2 → 1.1.0

package/dist/utils/update-notifier-middleware.js

@@ -0,0 +1,276 @@
+import chalk from 'chalk';
+import path from 'path';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { settingsService } from './settings-service.js';
+import { logService } from './log-service.js';
+import latestVersion from 'latest-version';
+import semver from 'semver';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import prompts from 'prompts';
+const execAsync = promisify(exec);
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PACKAGE_JSON_PATH = path.join(__dirname, '..', '..', 'package.json');
+class UpdateNotifierMiddleware {
+    async shouldNotify(commandName) {
+        const settings = await settingsService.getSettings();
+        return settings.enabledUpgradeCommands.includes(commandName);
+    }
+    async getLatestVersion(packageName) {
+        try {
+            const version = await latestVersion(packageName);
+            return version;
+        }
+        catch (error) {
+            try {
+                const { stdout } = await execAsync(`npm view ${packageName} version`);
+                const version = stdout.trim();
+                return version;
+            }
+            catch (fallbackError) {
+                console.error('Erro ao obter versão mais recente:', fallbackError);
+                return null;
+            }
+        }
+    }
+    /**
+     * Obtém a versão mais recente com timeout configurável
+     * @param packageName Nome do pacote
+     * @param timeoutMs Timeout em milissegundos
+     * @returns Promise com a versão ou null em caso de timeout/erro
+     */
+    async getLatestVersionWithTimeout(packageName, timeoutMs) {
+        try {
+            // Criar uma Promise de timeout
+            const timeoutPromise = new Promise((_, reject) => {
+                setTimeout(() => reject(new Error('Timeout na verificação de versão')), timeoutMs);
+            });
+            // Correr as duas promises em paralelo - a primeira a resolver/rejeitar vence
+            const version = await Promise.race([
+                this.getLatestVersion(packageName),
+                timeoutPromise
+            ]);
+            return version;
+        }
+        catch (error) {
+            // Em caso de timeout ou erro, retornar null silenciosamente
+            return null;
+        }
+    }
+    /**
+     * Verifica se há uma nova versão disponível
+     * @param currentVersion Versão atual
+     * @param latestVersion Versão mais recente
+     * @returns boolean true se houver nova versão
+     */
+    isNewVersionAvailable(currentVersion, latestVersion) {
+        // Validar versões
+        if (!this.isValidVersion(currentVersion) || !this.isValidVersion(latestVersion)) {
+            return false;
+        }
+        // Verificar se a versão atual é menor que a mais recente
+        return semver.lt(currentVersion, latestVersion);
+    }
+    /**
+     * Obtém a versão atual do package.json
+     * @returns string com a versão atual
+     */
+    getCurrentVersion() {
+        try {
+            const packageJson = JSON.parse(readFileSync(PACKAGE_JSON_PATH, 'utf-8'));
+            return packageJson.version;
+        }
+        catch (error) {
+            throw new Error('Não foi possível ler a versão atual do package.json');
+        }
+    }
+    isValidVersion(version) {
+        if (!version) {
+            return false;
+        }
+        const isValid = semver.valid(version);
+        return isValid !== null;
+    }
+    getUpdateType(currentVersion, latestVersion) {
+        const diff = semver.diff(currentVersion, latestVersion);
+        if (!diff) {
+            return 'unknown';
+        }
+        return diff;
+    }
+    /**
+     * Exibe prompt interativo perguntando se o usuário deseja atualizar
+     * @param latestVersion Versão mais recente disponível
+     * @returns Promise<boolean> true se o usuário aceitar atualizar
+     */
+    async promptUserForUpdate(latestVersion) {
+        try {
+            const response = await prompts({
+                type: 'confirm',
+                name: 'shouldUpdate',
+                message: `Deseja atualizar para a versão ${latestVersion} agora? (Y=Sim, n=Não)`,
+                initial: true
+            });
+            // Se o usuário pressionar Ctrl+C, response será undefined
+            if (response === undefined) {
+                return false;
+            }
+            return response.shouldUpdate;
+        }
+        catch (error) {
+            // Em caso de erro no prompt, assumir que o usuário não quer atualizar
+            return false;
+        }
+    }
+    /**
+     * Exibe prompt de retry após falha na atualização
+     * @returns Promise<boolean> true se o usuário quiser tentar novamente
+     */
+    async promptForRetry() {
+        try {
+            const response = await prompts({
+                type: 'confirm',
+                name: 'shouldRetry',
+                message: 'Erro ao atualizar. Deseja tentar novamente?',
+                initial: true
+            });
+            // Se o usuário pressionar Ctrl+C, response será undefined
+            if (response === undefined) {
+                return false;
+            }
+            return response.shouldRetry;
+        }
+        catch (error) {
+            // Em caso de erro no prompt, assumir que o usuário não quer tentar novamente
+            return false;
+        }
+    }
+    /**
+     * Executa a atualização do pacote via npm install -g
+     * @param retryCount Número de tentativas já realizadas
+     * @returns Promise<void>
+     */
+    async executeUpdate(retryCount = 0) {
+        try {
+            // Executar comando de atualização
+            await execAsync('npm install -g specifica-br@latest', {
+                timeout: 60000, // Timeout de 60 segundos para o npm install
+            });
+            // Exibir mensagem de sucesso
+            console.log('specifica-br atualizado com sucesso!');
+            // Encerrar processo após atualização bem-sucedida
+            process.exit(0);
+        }
+        catch (error) {
+            // Log de erro
+            logService.logError(error instanceof Error ? error : new Error(String(error)), 'UpdateInterceptorMiddleware - Falha na atualização');
+            // Exibir mensagem de erro para o usuário
+            console.error('Erro ao atualizar specifica-br:');
+            console.error(error instanceof Error ? error.message : String(error));
+            // Perguntar se deseja tentar novamente
+            const shouldRetry = await this.promptForRetry();
+            if (shouldRetry) {
+                // Limitar a 3 tentativas para evitar loop infinito
+                if (retryCount < 2) {
+                    console.log('Tentando novamente...');
+                    await this.executeUpdate(retryCount + 1);
+                }
+                else {
+                    console.error('Número máximo de tentativas atingido. Por favor, tente atualizar manualmente.');
+                }
+            }
+            // Se não quiser tentar novamente ou atingir limite de tentativas, lançar erro
+            throw error;
+        }
+    }
+    /**
+     * Exibe notificação e prompt interativo para atualização
+     * @param latestVersion Versão mais recente disponível
+     * @param originalAction Função original a ser executada se recusar atualização
+     * @returns Promise<void>
+     */
+    async displayNotificationWithPrompt(latestVersion, originalAction) {
+        const currentVersion = this.getCurrentVersion();
+        const type = this.getUpdateType(currentVersion, latestVersion);
+        this.displayNotification({
+            name: 'specifica-br',
+            currentVersion,
+            latestVersion,
+            type
+        });
+        const shouldUpdate = await this.promptUserForUpdate(latestVersion);
+        if (shouldUpdate) {
+            await this.executeUpdate();
+        }
+        else {
+            await originalAction();
+        }
+    }
+    /**
+     * Envelopa uma função com verificação de atualização
+     * @param commandName Nome do comando sendo executado
+     * @param originalAction Função original a ser executada
+     * @returns Promise com o resultado da função original
+     */
+    async wrap(commandName, originalAction) {
+        // Verificar se o comando está na lista de comandos habilitados para verificação
+        const settings = await settingsService.getSettings();
+        const enabledCommands = settings.enabledUpgradeCommands || [];
+        if (!enabledCommands.includes(commandName)) {
+            // Se não estiver na lista, executar ação original sem verificação
+            await originalAction();
+            return;
+        }
+        // Obter configuração de timeout
+        const timeoutMs = settings.versionCheckTimeoutMs || 1500;
+        try {
+            // Verificar versão mais recente com timeout
+            const latestVersion = await this.getLatestVersionWithTimeout('specifica-br', timeoutMs);
+            // Se não conseguiu obter versão (timeout, erro, etc.), executar ação original
+            if (!latestVersion) {
+                await originalAction();
+                return;
+            }
+            // Obter versão atual
+            const currentVersion = this.getCurrentVersion();
+            // Verificar se há nova versão disponível
+            if (!this.isNewVersionAvailable(currentVersion, latestVersion)) {
+                // Se não há nova versão, executar ação original
+                await originalAction();
+                return;
+            }
+            // Se chegou aqui, há nova versão disponível - iniciar fluxo de atualização
+            await this.displayNotificationWithPrompt(latestVersion, originalAction);
+        }
+        catch (error) {
+            // Em caso de qualquer erro no fluxo de interceptação, executar ação original
+            logService.logError(error instanceof Error ? error : new Error(String(error)), `UpdateInterceptorMiddleware - Erro no comando ${commandName}`);
+            await originalAction();
+        }
+    }
+    displayNotification(update) {
+        const { name, currentVersion, latestVersion, type } = update;
+        const lines = [
+            'Update disponível',
+            '',
+            name,
+            `${currentVersion} → ${latestVersion}`
+        ];
+        const boxWidth = 60;
+        const horizontalBorder = '─'.repeat(boxWidth);
+        console.log('');
+        console.log(chalk.bgYellow.black('┌' + horizontalBorder + '┐'));
+        lines.forEach(line => {
+            const content = line.trim() === '' ? '' : line;
+            const padding = Math.max(0, boxWidth - content.length);
+            const leftPadding = Math.floor(padding / 2);
+            const rightPadding = padding - leftPadding;
+            const paddedLine = ' '.repeat(leftPadding) + content + ' '.repeat(rightPadding);
+            console.log(chalk.bgYellow.black('│' + paddedLine + '│'));
+        });
+        console.log(chalk.bgYellow.black('└' + horizontalBorder + '┘'));
+        console.log('');
+    }
+}
+export const updateNotifierMiddleware = new UpdateNotifierMiddleware();

package/package.json

@@ -1,25 +1,28 @@
 {
   "name": "specifica-br",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "Ferramenta de automação para desenvolvimento guiado por especificações (Spec Driven Development - SDD) com IA. Otimizado para o ecossistema brasileiro.",
+  "type": "module",
   "main": "dist/index.js",
   "bin": {
     "specifica-br": "./dist/index.js"
   },
   "scripts": {
-    "build": "tsc && npm run copy:assets",
+    "build": "tsc && npm run copy:assets && npm run add:shebang",
     "copy:assets": "npx copyfiles -u 2 \"src/assets/**/*\" dist",
+    "add:shebang": "sed -i '1i#!/usr/bin/env node' dist/index.js",
     "start": "node dist/index.js",
-    "dev": "tsc && npm run copy:assets && node dist/index.js"
+    "dev": "tsc && npm run copy:assets && npm run add:shebang && node dist/index.js"
   },
   "keywords": [
     "spec driven development",
+    "spec-driven-development",
+    "spec-driven",
     "SSD",
     "spec",
     "especificar",
     "ai",
     "ia",
-    "spec-driven-development",
     "automation",
     "opencode",
     "brazil",
@@ -38,11 +41,14 @@
     "chalk": "^4.1.2",
     "commander": "^14.0.3",
     "fs-extra": "^11.3.3",
-    "prompts": "^2.4.2"
+    "latest-version": "^9.0.0",
+    "prompts": "^2.4.2",
+    "semver": "^7.7.4"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",
     "@types/node": "^25.2.3",
+    "@types/semver": "^7.7.1",
     "copyfiles": "^2.4.1",
     "typescript": "^5.3.3"
   }