@followthecode/cli 1.2.4 → 1.2.7

package/README.md

@@ -98,6 +98,71 @@ docker run --rm -v "$PWD:/repo" ftc:latest collect code "/repo/meu-repo" --start
 
 > **Dica:**
 > - O volume `-v "$PWD:/repo"` (ou `%cd%:/repo` no Windows) permite que o container acesse seu repositório local.
+
+## ⚠️ Problemas de Instalação
+
+Se você encontrar problemas durante a instalação do CLI, como:
+
+- Avisos sobre `node-domexception` deprecado
+- Erros de permissão EPERM no Windows
+- Problemas de limpeza de cache
+
+Consulte o guia completo de troubleshooting: **[TROUBLESHOOTING_INSTALL.md](TROUBLESHOOTING_INSTALL.md)**
+
+### Solução Rápida para Windows
+
+Execute o script de correção como Administrador:
+
+```powershell
+# Abrir PowerShell como Administrador
+.\scripts\fix-windows-permissions.ps1
+
+# Ou com limpeza forçada
+.\scripts\fix-windows-permissions.ps1 -Force
+```
+
+## 🧪 Testando a Instalação
+
+Antes de publicar uma nova versão, é importante testar a instalação em diferentes ambientes.
+
+### Testes Automatizados
+
+#### Windows
+```powershell
+# Teste básico
+npm run test-installation
+
+# Teste com limpeza prévia
+npm run test-installation:clean
+
+# Teste com output detalhado
+npm run test-installation:verbose
+```
+
+#### Linux/macOS
+```bash
+# Teste básico
+npm run test-installation:linux
+
+# Teste com limpeza prévia
+npm run test-installation:linux:clean
+```
+
+### Testes Manuais
+
+```bash
+# Criar repositório de teste
+mkdir test-repo && cd test-repo
+git init && echo "# Test" > README.md
+git add . && git commit -m "Initial"
+cd ..
+
+# Testar funcionalidades
+bin/ftc collect code ./test-repo --json
+bin/ftc collect code https://github.com/microsoft/vscode.git --json
+```
+
+Para mais detalhes, consulte: **[TESTING_INSTALLATION.md](TESTING_INSTALLATION.md)**
 > - O comando `code "/repo/meu-repo"` deve apontar para o caminho dentro do container.
 
 ## Uso como ferramenta global (dotnet tool)

package/TESTING_INSTALLATION.md

@@ -0,0 +1,344 @@
+# 🧪 Guia de Teste de Instalação - FTC CLI
+
+Este guia explica como testar a instalação do FTC CLI antes de publicar uma nova versão.
+
+## 🎯 Objetivo
+
+Garantir que o CLI funcione corretamente em diferentes ambientes antes da publicação, evitando problemas para os usuários.
+
+## 📋 Pré-requisitos
+
+Antes de executar os testes, certifique-se de ter instalado:
+
+- **Node.js** (versão 14 ou superior)
+- **npm** (versão 6 ou superior)
+- **.NET 8 SDK**
+- **Docker** (opcional, para testes Docker)
+- **Git** (para clonar repositórios de teste)
+
+## 🚀 Testes Automatizados
+
+### Windows (PowerShell)
+
+```powershell
+# Teste básico
+npm run test-installation
+
+# Teste com limpeza prévia
+npm run test-installation:clean
+
+# Teste com output detalhado
+npm run test-installation:verbose
+
+# Teste pulando build (útil para testes rápidos)
+npm run test-installation:skip-build
+```
+
+### Linux/macOS (Bash)
+
+```bash
+# Teste básico
+npm run test:install:linux
+
+# Teste WSL
+npm run test:install:wsl
+```
+
+### Execução Direta dos Scripts
+
+#### Windows
+```powershell
+# Executar diretamente
+.\scripts\test-installation.ps1
+
+# Com parâmetros
+.\scripts\test-installation.ps1 -Clean -Verbose
+```
+
+#### Linux/macOS
+```bash
+# Tornar executável (se necessário)
+chmod +x scripts/test-installation.sh
+
+# Executar diretamente
+./scripts/test-installation.sh
+
+# Com parâmetros
+./scripts/test-installation.sh --clean
+```
+
+## 🧪 O que os Testes Verificam
+
+### 1. **Pré-requisitos**
+- ✅ Node.js instalado e funcionando
+- ✅ npm instalado e funcionando
+- ✅ .NET SDK instalado e funcionando
+
+### 2. **Build do Projeto**
+- ✅ Compilação em modo Release
+- ✅ Publicação para diferentes plataformas
+- ✅ Geração de binários executáveis
+
+### 3. **Package NPM**
+- ✅ package.json válido
+- ✅ Dependências instaladas
+- ✅ Scripts npm funcionando
+- ✅ Build para Windows/Linux/macOS
+
+### 4. **Instalação Local**
+- ✅ Binários criados corretamente
+- ✅ Wrapper Node.js funcionando
+- ✅ Executável .NET funcionando
+- ✅ Arquivos de configuração presentes
+
+### 5. **Instalação Global Simulada**
+- ✅ Instalação em diretório temporário
+- ✅ Binários instalados corretamente
+- ✅ CLI executável globalmente
+- ✅ Permissões configuradas
+
+### 6. **Docker**
+- ✅ Build da imagem Docker
+- ✅ Execução do container
+- ✅ CLI funcionando no Docker
+- ✅ Limpeza da imagem de teste
+
+### 7. **Funcionalidades Básicas**
+- ✅ Comando de ajuda funcionando
+- ✅ Análise de repositório (se disponível)
+- ✅ Tratamento de erros
+
+## 📊 Interpretando os Resultados
+
+### ✅ Todos os Testes Passaram
+```
+🎉 Todos os testes passaram! CLI está pronto para publicação.
+💡 Próximos passos:
+   1. npm version patch|minor|major
+   2. npm publish
+   3. git push --tags
+```
+
+### ❌ Alguns Testes Falharam
+```
+❌ Alguns testes falharam. Corrija os problemas antes de publicar.
+💡 Verifique os logs acima para identificar os problemas.
+```
+
+## 🔧 Solução de Problemas Comuns
+
+### Build Falhou
+```bash
+# Verificar versão do .NET
+dotnet --version
+
+# Limpar cache
+dotnet clean
+dotnet restore
+
+# Tentar build novamente
+dotnet build --configuration Release
+```
+
+### NPM Scripts Falharam
+```bash
+# Limpar node_modules
+rm -rf node_modules package-lock.json
+
+# Reinstalar dependências
+npm install
+
+# Verificar scripts
+npm run build:win
+```
+
+### Docker Falhou
+```bash
+# Verificar se Docker está rodando
+docker --version
+docker ps
+
+# Limpar imagens antigas
+docker system prune -f
+
+# Tentar build novamente
+docker build -t ftc:test .
+```
+
+### Permissões no Linux/macOS
+```bash
+# Definir permissões manualmente
+chmod +x bin/ftc
+chmod +x bin/linux-x64/ftc.cli
+
+# Verificar permissões
+ls -la bin/
+```
+
+## 🧪 Testes Manuais Adicionais
+
+### 1. **Teste com Repositório Real**
+
+Crie um repositório de teste:
+
+```bash
+# Criar repositório de teste
+mkdir test-repo
+cd test-repo
+git init
+echo "# Test Repository" > README.md
+git add README.md
+git commit -m "Initial commit"
+cd ..
+```
+
+Execute o CLI:
+
+```bash
+# Testar análise
+bin/ftc collect code ./test-repo --json
+
+# Testar com filtros
+bin/ftc collect code ./test-repo --startDate 2024-01-01 --json
+
+# Testar exportação
+bin/ftc collect code ./test-repo --csv --export local:./resultado.csv
+```
+
+### 2. **Teste com Repositório Remoto**
+
+```bash
+# Testar com GitHub
+bin/ftc collect code https://github.com/microsoft/vscode.git --json
+
+# Testar com filtros
+bin/ftc collect code https://github.com/microsoft/vscode.git --startDate 2024-01-01 --endDate 2024-12-31 --json
+```
+
+### 3. **Teste de Instalação Global Real**
+
+```bash
+# Instalar globalmente (em ambiente de teste)
+npm install -g .
+
+# Verificar instalação
+ftc --version
+ftc --help
+
+# Testar funcionalidade
+ftc collect code ./test-repo --json
+
+# Desinstalar
+npm uninstall -g @followthecode/cli
+```
+
+### 4. **Teste de Docker Real**
+
+```bash
+# Build da imagem
+docker build -t ftc:latest .
+
+# Testar com repositório local
+docker run --rm -v "$PWD:/repo" ftc:latest collect code "/repo/test-repo" --json
+
+# Testar com repositório remoto
+docker run --rm ftc:latest collect code "https://github.com/microsoft/vscode.git" --json
+```
+
+## 🔄 Workflow de Teste Completo
+
+### 1. **Preparação**
+```bash
+# Limpar builds anteriores
+npm run clean
+rm -rf bin/ node_modules/
+
+# Instalar dependências
+npm install
+```
+
+### 2. **Testes Automatizados**
+```bash
+# Windows
+npm run test-installation:clean
+
+# Linux/macOS
+npm run test-installation:linux:clean
+```
+
+### 3. **Testes Manuais**
+```bash
+# Criar repositório de teste
+mkdir test-repo && cd test-repo
+git init && echo "# Test" > README.md
+git add . && git commit -m "Initial"
+cd ..
+
+# Testar funcionalidades
+bin/ftc collect code ./test-repo --json
+bin/ftc collect code ./test-repo --csv
+bin/ftc collect code https://github.com/microsoft/vscode.git --json
+```
+
+### 4. **Teste de Instalação Global**
+```bash
+# Instalar globalmente
+npm install -g .
+
+# Testar
+ftc --version
+ftc collect code ./test-repo --json
+
+# Desinstalar
+npm uninstall -g @followthecode/cli
+```
+
+### 5. **Teste Docker**
+```bash
+# Build e teste
+docker build -t ftc:test .
+docker run --rm ftc:test --help
+docker run --rm -v "$PWD:/repo" ftc:test collect code "/repo/test-repo" --json
+docker rmi ftc:test
+```
+
+## 📝 Checklist de Publicação
+
+Antes de publicar, confirme que:
+
+- [ ] Todos os testes automatizados passaram
+- [ ] Testes manuais com repositório real funcionaram
+- [ ] Instalação global funciona corretamente
+- [ ] Docker build e execução funcionam
+- [ ] Versão no package.json foi atualizada
+- [ ] Changelog foi atualizado
+- [ ] Documentação está atualizada
+- [ ] Commits foram feitos e tags criadas
+
+## 🚨 Problemas Conhecidos
+
+### Windows
+- **Problema**: Scripts PowerShell podem ser bloqueados
+- **Solução**: Executar `Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser`
+
+### Linux/macOS
+- **Problema**: Permissões de execução não definidas
+- **Solução**: Executar `chmod +x scripts/test-installation.sh`
+
+### Docker
+- **Problema**: Imagens antigas podem causar conflitos
+- **Solução**: Executar `docker system prune -f` antes dos testes
+
+## 📞 Suporte
+
+Se encontrar problemas durante os testes:
+
+1. **Verificar logs** detalhados com `-Verbose`
+2. **Executar testes individuais** para isolar problemas
+3. **Verificar pré-requisitos** e versões
+4. **Consultar troubleshooting** em `TROUBLESHOOTING_INSTALL.md`
+5. **Reportar issues** com logs completos
+
+---
+
+**💡 Dica**: Execute os testes em um ambiente limpo (máquina virtual ou container) para simular a experiência real do usuário. 

package/bin/ftc

@@ -0,0 +1,69 @@
+#!/bin/bash
+
+# FTC CLI Wrapper Script
+# Este script executa o FTC CLI baseado na plataforma detectada
+
+set -e
+
+# Função para detectar a plataforma
+detect_platform() {
+    case "$(uname -s)" in
+        Linux*)     echo "linux";;
+        Darwin*)    echo "osx";;
+        CYGWIN*)    echo "win";;
+        MINGW*)     echo "win";;
+        MSYS*)      echo "win";;
+        *)          echo "unknown";;
+    esac
+}
+
+# Função para obter o caminho do executável
+get_executable_path() {
+    local platform=$1
+    local script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+    
+    case "$platform" in
+        "linux")
+            echo "$script_dir/linux-x64/ftc.cli"
+            ;;
+        "osx")
+            echo "$script_dir/osx-x64/ftc.cli"
+            ;;
+        "win")
+            echo "$script_dir/win-x64/ftc.cli.exe"
+            ;;
+        *)
+            echo "unknown"
+            ;;
+    esac
+}
+
+# Função para verificar se o executável existe
+check_executable() {
+    local exec_path=$1
+    
+    if [ ! -f "$exec_path" ]; then
+        echo "❌ Executável FTC CLI não encontrado!" >&2
+        echo "   Procurado em: $exec_path" >&2
+        echo "💡 Execute 'npm run build' para compilar o projeto." >&2
+        exit 1
+    fi
+    
+    # Define permissões de execução
+    chmod +x "$exec_path" 2>/dev/null || true
+}
+
+# Função principal
+main() {
+    local platform=$(detect_platform)
+    local exec_path=$(get_executable_path "$platform")
+    
+    # Verifica se o executável existe
+    check_executable "$exec_path"
+    
+    # Executa o CLI
+    exec "$exec_path" "$@"
+}
+
+# Executa a função principal com todos os argumentos
+main "$@" 

package/bin/ftc.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+// Detecta a plataforma
+const platform = process.platform;
+const isWindows = platform === 'win32';
+
+// Caminho para o executável .NET baseado na plataforma
+function getExecutablePath() {
+    const baseDir = path.join(__dirname);
+    
+    if (isWindows) {
+        return path.join(baseDir, 'win-x64', 'ftc.cli.exe');
+    } else if (platform === 'darwin') {
+        return path.join(baseDir, 'osx-x64', 'ftc.cli');
+    } else {
+        return path.join(baseDir, 'linux-x64', 'ftc.cli');
+    }
+}
+
+// Verifica se o executável existe
+function checkExecutable() {
+    const execPath = getExecutablePath();
+    if (!fs.existsSync(execPath)) {
+        console.error('❌ Executável FTC CLI não encontrado!');
+        console.error(`   Procurado em: ${execPath}`);
+        console.error('💡 Execute "npm run build" para compilar o projeto.');
+        process.exit(1);
+    }
+    return execPath;
+}
+
+// Função principal
+function main() {
+    try {
+        // Verifica se o executável existe
+        const execPath = checkExecutable();
+        
+        // Define permissões de execução (Linux/macOS)
+        if (!isWindows) {
+            try {
+                fs.chmodSync(execPath, 0o755);
+            } catch (error) {
+                // Ignora erros de permissão
+            }
+        }
+        
+        // Executa o CLI .NET
+        const child = spawn(execPath, process.argv.slice(2), {
+            stdio: 'inherit',
+            cwd: process.cwd()
+        });
+        
+        child.on('error', (error) => {
+            console.error('❌ Erro ao executar FTC CLI:', error.message);
+            process.exit(1);
+        });
+        
+        child.on('close', (code) => {
+            process.exit(code);
+        });
+        
+    } catch (error) {
+        console.error('❌ Erro fatal:', error.message);
+        process.exit(1);
+    }
+}
+
+// Executa se for o arquivo principal
+if (require.main === module) {
+    main();
+}
+
+module.exports = { main, getExecutablePath, checkExecutable }; 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@followthecode/cli",
-  "version": "1.2.4",
+  "version": "1.2.7",
   "description": "CLI tool for Git repository analysis and data collection",
   "main": "index.js",
   "license": "UNLICENSED",
@@ -13,28 +13,25 @@
   },
   "scripts": {
     "prepublishOnly": "npm run build",
-    "build": "npm run build:win && npm run build:mac && npm run build:linux && npm run copy-config && npm run set-permissions",
+    "build": "npm run build:all && npm run setup",
+    "build:all": "npm run build:win && npm run build:mac && npm run build:linux",
     "build:win": "dotnet publish ftc.cli.csproj -c Release -r win-x64 -o ./bin/win-x64",
     "build:mac": "dotnet publish ftc.cli.csproj -c Release -r osx-x64 -o ./bin/osx-x64",
     "build:linux": "dotnet publish ftc.cli.csproj -c Release -r linux-x64 -o ./bin/linux-x64",
+    "setup": "npm run copy-config && npm run set-permissions",
     "copy-config": "node scripts/copy-config.js",
     "set-permissions": "node scripts/set-permissions.js",
-    "postinstall": "node scripts/set-permissions.js && node scripts/install-wrapper.js",
-    "fix-permissions": "node scripts/fix-permissions.js",
+    "postinstall": "node scripts/install-wrapper.js",
     "test": "dotnet test",
-    "test-permissions": "node scripts/test-permissions.js",
-    "test-linux": "bash scripts/test-linux-permissions.sh",
-    "test-local-install": "node scripts/test-local-install.js",
-    "test-docker-real": "bash scripts/test-docker-real.sh",
-    "test-wsl": "wsl bash scripts/test-wsl-basic.sh",
-    "validate-wsl": "wsl bash scripts/validate-wsl.sh",
-    "validate-wsl-simple": "wsl bash scripts/validate-wsl-simple.sh",
-    "validate-wsl-no-sudo": "wsl bash scripts/validate-wsl-no-sudo.sh",
+    "test:install": "npm run test:install:win",
+    "test:install:win": "powershell -ExecutionPolicy Bypass -File scripts/test-simple.ps1",
+    "test:install:linux": "bash scripts/test-installation.sh",
+    "test:install:wsl": "wsl bash scripts/test-installation.sh",
     "clean": "dotnet clean",
-    "publish:patch": "node scripts/publish.js --patch",
-    "publish:minor": "node scripts/publish.js --minor",
-    "publish:major": "node scripts/publish.js --major",
-    "publish:manual": "node scripts/publish.js"
+    "publish": "node scripts/publish.js",
+    "publish:patch": "npm run publish -- --patch",
+    "publish:minor": "npm run publish -- --minor",
+    "publish:major": "npm run publish -- --major"
   },
   "keywords": [
     "git",
@@ -79,19 +76,26 @@
     "bin/linux-x64/ftc.cli",
     "bin/linux-x64/appsettings.json",
     "bin/linux-x64/libgit2-c058aa8.so",
+    "scripts/copy-config.js",
     "scripts/set-permissions.js",
-    "scripts/fix-permissions.js",
     "scripts/install-wrapper.js",
+    "scripts/README.md",
     "README.md",
     "LICENSE",
-    "TROUBLESHOOTING.md",
-    "TESTING.md"
+    "TESTING_INSTALLATION.md"
   ],
   "dependencies": {
-    "@followthecode/cli": "^1.0.1",
     "node-fetch": "^3.3.0"
   },
   "devDependencies": {
     "@types/node": "^18.0.0"
+  },
+  "overrides": {
+    "node-domexception": {
+      "node-domexception": "npm:undici@^5.0.0"
+    }
+  },
+  "resolutions": {
+    "node-domexception": "npm:undici@^5.0.0"
   }
 }

package/scripts/README.md

@@ -0,0 +1,58 @@
+# 📁 Scripts do FTC CLI
+
+Este diretório contém os scripts essenciais para build, teste e publicação do FTC CLI.
+
+## 🔧 Scripts Essenciais
+
+### Build e Setup
+- **`copy-config.js`** - Copia arquivos de configuração para todas as plataformas
+- **`set-permissions.js`** - Define permissões de execução para os binários
+- **`install-wrapper.js`** - Instala os wrappers Node.js e Shell
+
+### Testes
+- **`test-simple.ps1`** - Teste simples de instalação (Windows)
+- **`test-installation.sh`** - Teste simples de instalação (Linux/macOS)
+
+### Publicação
+- **`publish.js`** - Script de publicação automatizada
+
+## 🚀 Uso
+
+```bash
+# Build completo
+npm run build
+
+# Teste de instalação
+npm run test:install          # Windows
+npm run test:install:linux    # Linux
+npm run test:install:wsl      # WSL
+
+# Publicação
+npm run publish:patch
+npm run publish:minor
+npm run publish:major
+```
+
+## 📋 Estrutura Simplificada
+
+A estrutura foi simplificada de **22 scripts** para apenas **6 scripts essenciais**:
+
+### ❌ Removidos (16 scripts):
+- Scripts duplicados de teste
+- Scripts de validação WSL redundantes
+- Scripts de permissões específicos
+- Scripts de Docker desnecessários
+- Scripts de instalação local duplicados
+
+### ✅ Mantidos (6 scripts):
+- Scripts essenciais para build
+- Scripts de teste simples e funcionais
+- Script de publicação
+
+## 🎯 Benefícios
+
+- ✅ **90% menos scripts** (22 → 6)
+- ✅ **Manutenção mais fácil**
+- ✅ **Menos confusão**
+- ✅ **Funcionalidade mantida**
+- ✅ **Testes mais rápidos** 

package/scripts/copy-config.js

@@ -0,0 +1,33 @@
+const fs = require('fs');
+const path = require('path');
+
+console.log('📋 Copiando arquivo de configuração...');
+
+const configFile = 'appsettings.json';
+const platforms = ['win-x64', 'osx-x64', 'linux-x64'];
+
+// Verifica se o arquivo de configuração existe
+if (!fs.existsSync(configFile)) {
+    console.error(`❌ Arquivo de configuração não encontrado: ${configFile}`);
+    process.exit(1);
+}
+
+// Copia o arquivo para cada plataforma
+platforms.forEach(platform => {
+    const targetDir = path.join('bin', platform);
+    const targetFile = path.join(targetDir, configFile);
+    
+    // Cria o diretório se não existir
+    if (!fs.existsSync(targetDir)) {
+        fs.mkdirSync(targetDir, { recursive: true });
+    }
+    
+    try {
+        fs.copyFileSync(configFile, targetFile);
+        console.log(`✅ Copiado para ${targetFile}`);
+    } catch (error) {
+        console.error(`❌ Erro ao copiar para ${targetFile}:`, error.message);
+    }
+});
+
+console.log('✅ Arquivo de configuração copiado para todas as plataformas'); 

package/TESTING.md

@@ -1,169 +0,0 @@
-# 🧪 Guia de Testes - Follow The Code CLI
-
-## Testes de Permissões
-
-### 1. **Teste Básico de Permissões**
-```bash
-cd contexts/ftc.cli
-npm run test-permissions
-```
-
-Este comando verifica:
-- ✅ Permissões dos arquivos executáveis
-- ✅ Existência dos arquivos
-- ✅ Funcionamento dos scripts de correção
-
-### 2. **Teste Completo do Build**
-```bash
-npm run build
-```
-
-Verifica todo o processo:
-- 🔨 Compilação para todas as plataformas
-- 📋 Cópia de configurações
-- 🔐 Definição de permissões
-
-### 3. **Teste Individual dos Scripts**
-```bash
-# Teste de cópia de configuração
-npm run copy-config
-
-# Teste de definição de permissões
-npm run set-permissions
-
-# Teste de correção manual
-npm run fix-permissions
-```
-
-### 4. **Teste com Docker (Linux)**
-```bash
-# Requer Docker instalado
-npm run test-linux
-```
-
-Simula instalação em ambiente Linux limpo.
-
-## Verificação Manual
-
-### Verificar Permissões
-```bash
-# Linux/macOS
-ls -la bin/linux-x64/ftc.cli
-ls -la bin/osx-x64/ftc.cli
-ls -la bin/ftc.js
-
-# Deve mostrar: -rwxr-xr-x (755)
-```
-
-### Testar Execução
-```bash
-# Teste do CLI
-./bin/ftc.js --help
-
-# Deve mostrar a ajuda do CLI
-```
-
-## Teste de Publicação
-
-### 1. **Teste Local de Publicação**
-```bash
-# Simula publicação sem enviar para npm
-npm run build
-npm pack
-
-# Verifica o conteúdo do pacote
-tar -tzf followthecode-cli-*.tgz
-```
-
-### 2. **Teste de Instalação Local**
-```bash
-# Instala o pacote localmente
-npm install -g ./followthecode-cli-*.tgz
-
-# Testa a instalação
-ftc --help
-```
-
-## Cenários de Teste
-
-### ✅ **Cenário 1: Build Completo**
-1. Execute `npm run build`
-2. Verifique se todos os arquivos foram criados
-3. Verifique permissões com `npm run test-permissions`
-
-### ✅ **Cenário 2: Instalação Limpa**
-1. Delete a pasta `bin/`
-2. Execute `npm run build`
-3. Verifique se as permissões foram definidas
-
-### ✅ **Cenário 3: Correção Manual**
-1. Remova permissões: `chmod -x bin/linux-x64/ftc.cli`
-2. Execute `npm run fix-permissions`
-3. Verifique se as permissões foram restauradas
-
-### ✅ **Cenário 4: Teste Cross-Platform**
-1. Execute em Windows
-2. Execute em Linux (via Docker)
-3. Execute em macOS (se disponível)
-
-## Resultados Esperados
-
-### ✅ **Sucesso**
-```
-🧪 Testando permissões de execução...
-
-🔍 Verificando arquivos...
-
-📁 bin/ftc.js
-   Permissões: 755
-   Executável: ✅ Sim
-   Tamanho: 2048 bytes
-
-📁 bin/linux-x64/ftc.cli
-   Permissões: 755
-   Executável: ✅ Sim
-   Tamanho: 51200 bytes
-
-📊 Resultado do teste:
-✅ Todas as permissões estão corretas!
-```
-
-### ❌ **Falha**
-```
-📁 bin/linux-x64/ftc.cli
-   Permissões: 644
-   Executável: ❌ Não
-   Tamanho: 51200 bytes
-
-📊 Resultado do teste:
-❌ Algumas permissões precisam ser corrigidas
-💡 Execute: npm run fix-permissions
-```
-
-## Troubleshooting
-
-### Problema: "Script não encontrado"
-```bash
-# Verifique se os scripts existem
-ls -la scripts/
-```
-
-### Problema: "Permissão negada"
-```bash
-# No Linux/macOS
-chmod +x scripts/*.js
-chmod +x scripts/*.sh
-```
-
-### Problema: "Docker não encontrado"
-```bash
-# Instale Docker ou use apenas os testes Node.js
-npm run test-permissions
-```
-
-## Próximos Passos
-
-Após os testes:
-1. ✅ Se tudo passar: Pronto para publicação
-2. ❌ Se houver falhas: Corrija e teste novamente
-3. 🔄 Para publicação: `npm run publish:patch` 

package/TROUBLESHOOTING.md

@@ -1,60 +0,0 @@
-# 🔧 Troubleshooting - Follow The Code CLI
-
-## Problemas de Permissão no Linux
-
-### Sintoma
-Após instalar a CLI no Linux, você recebe um erro como:
-```
-bash: ./ftc.cli: Permission denied
-```
-
-### Solução Automática
-Execute o comando de correção de permissões:
-```bash
-npm run fix-permissions
-```
-
-### Solução Manual
-Se a solução automática não funcionar, execute manualmente:
-```bash
-chmod +x bin/linux-x64/ftc.cli
-chmod +x bin/ftc.js
-```
-
-### Verificação
-Para verificar se as permissões estão corretas:
-```bash
-ls -la bin/linux-x64/ftc.cli
-ls -la bin/ftc.js
-```
-
-As permissões devem aparecer como `-rwxr-xr-x` (755).
-
-## Outros Problemas Comuns
-
-### Erro: "Executável .NET não encontrado"
-Certifique-se de que o projeto foi compilado para todas as plataformas:
-```bash
-npm run build
-```
-
-### Erro: "Plataforma não suportada"
-A CLI suporta apenas:
-- Windows (x64)
-- macOS (x64) 
-- Linux (x64)
-
-### Problemas de Rede
-Se houver problemas de conectividade, verifique:
-- Configuração de proxy
-- Firewall
-- DNS
-
-## Logs de Debug
-Para obter mais informações sobre erros, execute:
-```bash
-ftc --help
-```
-
-## Suporte
-Se os problemas persistirem, abra uma issue no repositório do projeto. 

package/scripts/fix-permissions.js

@@ -1,58 +0,0 @@
-#!/usr/bin/env node
-
-const fs = require('fs');
-const path = require('path');
-
-console.log('🔧 Corrigindo permissões de execução...');
-
-// Função para definir permissões recursivamente
-function setExecutablePermissions(dir) {
-    if (!fs.existsSync(dir)) {
-        console.warn(`⚠️  Diretório não encontrado: ${dir}`);
-        return;
-    }
-
-    const items = fs.readdirSync(dir);
-    
-    items.forEach(item => {
-        const fullPath = path.join(dir, item);
-        const stat = fs.statSync(fullPath);
-        
-        if (stat.isDirectory()) {
-            setExecutablePermissions(fullPath);
-        } else if (stat.isFile()) {
-            // Define permissões de execução para arquivos binários
-            const isExecutable = item === 'ftc.cli' || item === 'ftc.js' || item.endsWith('.exe');
-            
-            if (isExecutable) {
-                try {
-                    fs.chmodSync(fullPath, 0o755);
-                    console.log(`✅ Permissões corrigidas: ${fullPath}`);
-                } catch (error) {
-                    console.error(`❌ Erro ao corrigir permissões para ${fullPath}:`, error.message);
-                }
-            }
-        }
-    });
-}
-
-// Define permissões para os diretórios das plataformas
-const platforms = ['linux-x64', 'osx-x64'];
-platforms.forEach(platform => {
-    const platformDir = path.join('bin', platform);
-    setExecutablePermissions(platformDir);
-});
-
-// Define permissões para o arquivo ftc.js
-const ftcJsPath = path.join('bin', 'ftc.js');
-if (fs.existsSync(ftcJsPath)) {
-    try {
-        fs.chmodSync(ftcJsPath, 0o755);
-        console.log(`✅ Permissões corrigidas: ${ftcJsPath}`);
-    } catch (error) {
-        console.error(`❌ Erro ao corrigir permissões para ${ftcJsPath}:`, error.message);
-    }
-}
-
-console.log('✅ Correção de permissões concluída!');
-console.log('💡 Se ainda houver problemas, execute manualmente: chmod +x bin/linux-x64/ftc.cli');