@aurora.purecore.codes/latest 1.0.0

package/TEST_INIT_COMMAND.md

@@ -0,0 +1,380 @@
+# Testing `aurora init` Command
+
+This guide helps you test the `aurora init` command that downloads pre-compiled binaries from GitHub releases.
+
+## Prerequisites
+
+- Node.js installed
+- Internet connection
+- WSL (if on Windows)
+
+## Test 1: Basic Init with Binary Download
+
+```bash
+# Create a test directory
+mkdir test-aurora-project
+cd test-aurora-project
+
+# Run aurora init
+aurora init
+```
+
+### Expected Output
+
+```
+🚀 Initializing Aurora project...
+
+✓ Created aurora.json
+✓ Created project directories
+⠋ Downloading Austral compiler...
+✓ Compiler v0.2.0 downloaded: /home/user/.aurora_austral/bin/austral
+✓ Compiler installed: .aurora/bin/austral
+⠋ Downloading standard library...
+✓ Standard library installed: .aurora/stdlib
+✓ Created src/Main.aui
+✓ Created src/Main.aum
+✓ Created Makefile
+✓ Created .gitignore
+
+✨ Project initialized successfully!
+
+Next steps:
+  1. Edit src/Main.aum
+  2. Run: make build
+  3. Run: ./main
+  4. Install packages: aurora install <package-name>
+```
+
+### Expected File Structure
+
+```
+test-aurora-project/
+├── .aurora/
+│   ├── bin/
+│   │   └── austral          # Downloaded compiler binary
+│   └── stdlib/              # Standard library
+│       ├── Tuples.aui
+│       ├── Tuples.aum
+│       ├── String.aui
+│       └── ...
+├── aurora_packages/         # Empty initially
+├── src/
+│   ├── Main.aui
+│   └── Main.aum
+├── aurora.json
+├── Makefile
+└── .gitignore
+```
+
+### Verify aurora.json
+
+```json
+{
+  "name": "test-aurora-project",
+  "version": "0.1.0",
+  "description": "Aurora Austral project",
+  "main": "src/Main.aum",
+  "scripts": {
+    "build": "make",
+    "test": "make test",
+    "clean": "make clean"
+  },
+  "dependencies": {},
+  "devDependencies": {},
+  "aurora": {
+    "compiler": "local",
+    "compilerPath": ".aurora/bin/austral",
+    "stdlibPath": ".aurora/stdlib"
+  }
+}
+```
+
+## Test 2: Build the Project
+
+```bash
+# Build using the downloaded compiler
+make build
+```
+
+### Expected Output
+
+```
+Building project...
+.aurora/bin/austral compile .aurora/stdlib/Tuples.aui,.aurora/stdlib/Tuples.aum ... src/Main.aui,src/Main.aum --entrypoint=Example.Main:main --output=main
+Build successful!
+```
+
+### Run the Program
+
+```bash
+./main
+```
+
+### Expected Output
+
+```
+Hello, Aurora Austral!
+```
+
+## Test 3: Init Without Binary Download
+
+```bash
+# Create another test directory
+mkdir test-no-binary
+cd test-no-binary
+
+# Run aurora init without downloading binaries
+aurora init --no-binary
+```
+
+### Expected Behavior
+
+- Creates project structure
+- Does NOT download compiler or stdlib
+- aurora.json will have `"compiler": "local"` but no paths
+- User must have `austral` in system PATH
+
+## Test 4: Verify Cached Binaries
+
+```bash
+# Check global cache
+ls -la ~/.aurora_austral/bin/
+ls -la ~/.aurora_austral/bin/stdlib/
+```
+
+### Expected Files
+
+```
+~/.aurora_austral/
+├── bin/
+│   └── austral              # Cached compiler (755 permissions)
+└── packages/                # Package cache (from aurora install)
+```
+
+## Test 5: Platform Detection
+
+The command should automatically detect your platform:
+
+- **Linux x64**: Downloads `austral-linux`
+- **macOS Intel**: Downloads `austral-macos`
+- **macOS ARM**: Downloads `austral-macos`
+- **Windows x64**: Downloads `austral-windows.exe`
+
+### Verify Platform Detection
+
+```bash
+node -e "console.log(require('os').platform(), require('os').arch())"
+```
+
+## Test 6: Second Init (Using Cache)
+
+```bash
+# Create another project
+mkdir test-cached
+cd test-cached
+
+# Run aurora init again
+aurora init
+```
+
+### Expected Behavior
+
+- Should show: "Standard library already cached"
+- Should copy from cache instead of downloading again
+- Much faster than first init
+
+## Troubleshooting
+
+### Error: "Failed to download compiler"
+
+**Possible causes:**
+1. No internet connection
+2. GitHub API rate limit exceeded
+3. Release v0.2.0 doesn't exist or binaries not uploaded
+
+**Solution:**
+- Check internet connection
+- Wait for GitHub rate limit to reset (1 hour)
+- Use `--no-binary` flag and install compiler manually
+
+### Error: "No binary available for platform"
+
+**Cause:** Your platform is not supported (e.g., 32-bit systems, ARM Linux)
+
+**Solution:**
+- Compile the compiler from source
+- Use `aurora init --no-binary`
+
+### Error: "Permission denied" when running ./main
+
+**Cause:** Binary doesn't have execute permissions
+
+**Solution:**
+```bash
+chmod +x .aurora/bin/austral
+chmod +x main
+```
+
+### Error: "cannot execute: required file not found"
+
+**Cause:** Binary was compiled with dynamic linking (Nix, etc.)
+
+**Solution:**
+- The official release binaries should be statically linked
+- If this happens, report it as a bug
+- Workaround: Install compiler from source
+
+## Verifying Binary Integrity
+
+Check the downloaded binary:
+
+```bash
+# Check file type
+file .aurora/bin/austral
+
+# Expected output (Linux):
+# .aurora/bin/austral: ELF 64-bit LSB executable, x86-64
+
+# Check version
+./.aurora/bin/austral --version
+
+# Expected output:
+# 0.2.0
+```
+
+## Testing on Different Platforms
+
+### Linux (WSL or Native)
+
+```bash
+cd /tmp
+mkdir aurora-test-linux
+cd aurora-test-linux
+aurora init
+make build
+./main
+```
+
+### macOS
+
+```bash
+cd /tmp
+mkdir aurora-test-macos
+cd aurora-test-macos
+aurora init
+make build
+./main
+```
+
+### Windows (via WSL)
+
+```bash
+# In WSL
+cd /mnt/c/Users/YourName/Desktop
+mkdir aurora-test-windows
+cd aurora-test-windows
+aurora init
+make build
+./main
+```
+
+## Performance Benchmarks
+
+### First Init (with download)
+- Expected time: 10-30 seconds (depends on internet speed)
+- Downloads: ~5-10 MB (compiler) + ~500 KB (stdlib)
+
+### Second Init (from cache)
+- Expected time: 1-3 seconds
+- No downloads, just file copying
+
+## Integration with VSCode Extension
+
+After running `aurora init`, the VSCode extension should:
+
+1. Detect `.aurora/bin/austral` compiler
+2. Use `.aurora/stdlib` for module resolution
+3. Validate imports against `aurora_packages/`
+4. Show install button for missing packages
+
+## Next Steps After Successful Init
+
+1. **Edit code**: Modify `src/Main.aum`
+2. **Build**: Run `make build`
+3. **Run**: Execute `./main`
+4. **Install packages**: `aurora install dpop-token`
+5. **Update packages**: `aurora update`
+
+## Reporting Issues
+
+If you encounter problems:
+
+1. Check this troubleshooting guide
+2. Verify your platform is supported
+3. Check GitHub release exists: https://github.com/austral/austral/releases/tag/v0.2.0
+4. Report issue with:
+   - Platform and architecture (`uname -a`)
+   - Node.js version (`node --version`)
+   - Full error message
+   - Output of `aurora init` command
+
+## Success Criteria
+
+✅ `aurora init` completes without errors
+✅ Compiler binary is downloaded and executable
+✅ Standard library is downloaded
+✅ `make build` compiles successfully
+✅ `./main` runs and prints "Hello, Aurora Austral!"
+✅ Second init uses cache (faster)
+✅ Project structure matches expected layout
+
+## Additional Tests
+
+### Test with Existing aurora.json
+
+```bash
+# Create aurora.json first
+echo '{"name":"test"}' > aurora.json
+
+# Run init
+aurora init
+
+# Should show: "⚠️  aurora.json already exists"
+# Should NOT overwrite existing file
+```
+
+### Test Makefile Detection
+
+```bash
+# After init, verify Makefile detects compiler
+grep "AU_COMPILER" Makefile
+
+# Should show:
+# ifneq (,$(wildcard .aurora/bin/austral))
+#     AU_COMPILER = .aurora/bin/austral
+```
+
+### Test .gitignore
+
+```bash
+cat .gitignore
+
+# Should include:
+# aurora_packages/
+# .aurora/bin/
+# .aurora/stdlib/
+# main
+```
+
+## Conclusion
+
+The `aurora init` command provides a seamless onboarding experience by:
+
+1. ✅ Creating project structure
+2. ✅ Downloading pre-compiled binaries
+3. ✅ Setting up standard library
+4. ✅ Generating working example code
+5. ✅ Creating intelligent Makefile
+6. ✅ Caching for faster subsequent inits
+
+This eliminates the need for users to manually compile the compiler or set up the environment!

package/TEST_LOCAL.md

@@ -0,0 +1,307 @@
+# Testando Localmente
+
+Guia para testar o `aurora init` localmente antes de fazer release.
+
+## Setup
+
+### 1. Instalar o aurora-npm localmente
+
+```bash
+cd aurora-npm
+npm install
+npm link
+```
+
+Isso cria um link simbólico global para o comando `aurora`.
+
+### 2. Compilar binário local
+
+```bash
+cd ../aurora-austral
+make
+```
+
+### 3. Simular estrutura de release
+
+Como ainda não temos releases no GitHub, vamos simular localmente:
+
+```bash
+cd aurora-npm
+
+# Criar estrutura de "releases" local
+mkdir -p releases
+cp ../aurora-austral/austral releases/austral-linux-x64
+chmod +x releases/austral-linux-x64
+
+# Copiar stdlib
+cp -r ../aurora-austral/standard/src releases/stdlib
+```
+
+### 4. Modificar temporariamente o código
+
+Para testar localmente sem GitHub, modifique `bin/aurora.js`:
+
+```javascript
+// Adicione no início da função downloadCompiler():
+async function downloadCompiler(version = 'latest') {
+    const spinner = ora('Downloading Austral compiler...').start();
+    
+    try {
+        const platform = getPlatform();
+        const binName = platform.startsWith('win') ? 'austral.exe' : 'austral';
+        
+        // TESTE LOCAL: Use binário local em vez de GitHub
+        const localBinary = path.join(__dirname, '..', 'releases', `austral-${platform}`);
+        if (await fs.pathExists(localBinary)) {
+            spinner.text = 'Using local binary for testing...';
+            const cachedBinPath = path.join(BIN_CACHE_DIR, binName);
+            await fs.copy(localBinary, cachedBinPath);
+            await fs.chmod(cachedBinPath, 0o755);
+            spinner.succeed(`Compiler installed: ${cachedBinPath}`);
+            return cachedBinPath;
+        }
+        
+        // Resto do código original...
+```
+
+## Testando
+
+### Teste 1: Init com binários
+
+```bash
+# Criar diretório de teste
+mkdir /tmp/test-aurora-init
+cd /tmp/test-aurora-init
+
+# Executar init
+aurora init
+
+# Verificar estrutura criada
+ls -la
+tree -L 2
+
+# Verificar binário
+./.aurora/bin/austral --version
+
+# Compilar exemplo
+make build
+
+# Executar
+./main
+```
+
+**Resultado esperado:**
+```
+Hello, Aurora Austral!
+```
+
+### Teste 2: Init sem binários
+
+```bash
+mkdir /tmp/test-aurora-no-binary
+cd /tmp/test-aurora-no-binary
+
+aurora init --no-binary
+
+# Deve usar austral do sistema
+which austral
+make build
+./main
+```
+
+### Teste 3: Instalar pacote
+
+```bash
+cd /tmp/test-aurora-init
+
+# Instalar pacote
+aurora install dpop-token
+
+# Verificar instalação
+ls aurora_packages/
+ls aurora_packages/dpop-token/
+```
+
+### Teste 4: Projeto existente
+
+```bash
+mkdir /tmp/test-existing
+cd /tmp/test-existing
+
+# Criar alguns arquivos primeiro
+mkdir src
+echo "test" > src/test.txt
+
+# Init deve respeitar arquivos existentes
+aurora init
+
+# Verificar que test.txt ainda existe
+cat src/test.txt
+```
+
+## Verificações
+
+### ✅ Checklist de Testes
+
+- [ ] `aurora init` cria todos os arquivos
+- [ ] `aurora init` baixa binário correto
+- [ ] `aurora init` baixa stdlib
+- [ ] Binário é executável
+- [ ] `make build` funciona
+- [ ] Programa compilado executa
+- [ ] `aurora init --no-binary` funciona
+- [ ] `aurora install` funciona após init
+- [ ] Arquivos existentes são preservados
+- [ ] `.gitignore` é criado corretamente
+- [ ] `aurora.json` tem configuração correta
+
+### 🔍 Verificar Arquivos Criados
+
+```bash
+cd /tmp/test-aurora-init
+
+# Estrutura
+tree -L 3
+
+# aurora.json
+cat aurora.json
+
+# Makefile
+cat Makefile
+
+# Exemplo
+cat src/Main.aui
+cat src/Main.aum
+
+# .gitignore
+cat .gitignore
+
+# Binário
+file .aurora/bin/austral
+.aurora/bin/austral --version
+
+# Stdlib
+ls .aurora/stdlib/
+```
+
+## Limpeza
+
+```bash
+# Remover link global
+npm unlink -g aurora-npm
+
+# Remover diretórios de teste
+rm -rf /tmp/test-aurora-*
+
+# Remover cache
+rm -rf ~/.aurora_austral
+```
+
+## Problemas Comuns
+
+### Erro: "austral: command not found"
+
+**Causa:** Binário não foi baixado ou não está executável
+
+**Solução:**
+```bash
+chmod +x .aurora/bin/austral
+ls -la .aurora/bin/
+```
+
+### Erro: "AUSTRAL_STDLIB not found"
+
+**Causa:** Stdlib não foi baixada
+
+**Solução:**
+```bash
+ls .aurora/stdlib/
+# Se vazio, baixar manualmente
+cp -r ../aurora-austral/standard/src .aurora/stdlib/
+```
+
+### Erro: "cannot execute: required file not found"
+
+**Causa:** Binário compilado com dependências dinâmicas (Nix)
+
+**Solução:**
+```bash
+# Recompilar sem Nix
+cd aurora-austral
+make clean
+make
+```
+
+### Erro: "Permission denied"
+
+**Causa:** Binário sem permissão de execução
+
+**Solução:**
+```bash
+chmod +x .aurora/bin/austral
+```
+
+## Teste de Integração Completo
+
+Script para testar tudo de uma vez:
+
+```bash
+#!/bin/bash
+
+set -e
+
+echo "🧪 Testing Aurora Init..."
+
+# Cleanup
+rm -rf /tmp/aurora-test
+mkdir -p /tmp/aurora-test
+cd /tmp/aurora-test
+
+# Test 1: Init
+echo "Test 1: aurora init"
+aurora init
+[ -f aurora.json ] || exit 1
+[ -f Makefile ] || exit 1
+[ -f .gitignore ] || exit 1
+[ -d src ] || exit 1
+[ -d .aurora ] || exit 1
+echo "✅ Test 1 passed"
+
+# Test 2: Build
+echo "Test 2: make build"
+make build
+[ -f main ] || exit 1
+echo "✅ Test 2 passed"
+
+# Test 3: Run
+echo "Test 3: ./main"
+OUTPUT=$(./main)
+[[ "$OUTPUT" == *"Hello"* ]] || exit 1
+echo "✅ Test 3 passed"
+
+# Test 4: Install package
+echo "Test 4: aurora install dpop-token"
+aurora install dpop-token
+[ -d aurora_packages/dpop-token ] || exit 1
+echo "✅ Test 4 passed"
+
+echo ""
+echo "🎉 All tests passed!"
+```
+
+Salve como `test-integration.sh` e execute:
+
+```bash
+chmod +x test-integration.sh
+./test-integration.sh
+```
+
+## Próximos Passos
+
+Após testar localmente com sucesso:
+
+1. ✅ Remover código de teste local
+2. ✅ Compilar binários para todas as plataformas
+3. ✅ Fazer release no GitHub
+4. ✅ Testar download real do GitHub
+5. ✅ Publicar no npm