@aurora.purecore.codes/latest 1.0.0 → 1.1.0

package/TEST_INIT_COMMAND.md

@@ -1,380 +0,0 @@
-# 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

@@ -1,307 +0,0 @@
-# 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