ether-code 0.1.8 → 0.1.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ether-code",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": "Ether - Le langage intentionnel",
   "main": "cli/compiler.js",
   "bin": {
@@ -37,8 +37,9 @@
     "cli/",
     "generators/",
     "lexer/",
-    "parsers/",
     "i18n/",
+    "ether-parser.js",
+    "ether-compiler.js",
     "README.md",
     "LICENSE"
   ]

package/cli/ether.js

@@ -1,700 +0,0 @@
-#!/usr/bin/env node
-
-const fs = require('fs')
-const path = require('path')
-const http = require('http')
-const { EtherCompiler } = require('./compiler')
-const { Watcher } = require('./watcher')
-
-const VERSION = '0.1.8'
-
-const COLORS = {
-  reset: '\x1b[0m',
-  bright: '\x1b[1m',
-  dim: '\x1b[2m',
-  red: '\x1b[31m',
-  green: '\x1b[32m',
-  yellow: '\x1b[33m',
-  blue: '\x1b[34m',
-  magenta: '\x1b[35m',
-  cyan: '\x1b[36m'
-}
-
-function log(msg, color = '') {
-  console.log(`${color}${msg}${COLORS.reset}`)
-}
-
-function logSuccess(msg) {
-  log(`✓ ${msg}`, COLORS.green)
-}
-
-function logError(msg) {
-  log(`✗ ${msg}`, COLORS.red)
-}
-
-function logInfo(msg) {
-  log(`ℹ ${msg}`, COLORS.cyan)
-}
-
-function logWarning(msg) {
-  log(`⚠ ${msg}`, COLORS.yellow)
-}
-
-function showBanner() {
-  console.log(`
-${COLORS.cyan}${COLORS.bright}
-  ███████╗████████╗██╗  ██╗███████╗██████╗ 
-  ██╔════╝╚══██╔══╝██║  ██║██╔════╝██╔══██╗
-  █████╗     ██║   ███████║█████╗  ██████╔╝
-  ██╔══╝     ██║   ██╔══██║██╔══╝  ██╔══██╗
-  ███████╗   ██║   ██║  ██║███████╗██║  ██║
-  ╚══════╝   ╚═╝   ╚═╝  ╚═╝╚══════╝╚═╝  ╚═╝
-${COLORS.reset}
-  ${COLORS.dim}Le langage intentionnel - v${VERSION}${COLORS.reset}
-`)
-}
-
-function showHelp() {
-  showBanner()
-  console.log(`
-${COLORS.bright}UTILISATION${COLORS.reset}
-  ether <commande> [options]
-
-${COLORS.bright}COMMANDES${COLORS.reset}
-  ${COLORS.cyan}init${COLORS.reset}              Initialiser un nouveau projet Ether
-  ${COLORS.cyan}build${COLORS.reset}             Compiler les fichiers .eth
-  ${COLORS.cyan}dev${COLORS.reset}               Mode développement (serveur + watch + live reload)
-  ${COLORS.cyan}check${COLORS.reset}             Vérifier la syntaxe sans compiler
-  ${COLORS.cyan}help${COLORS.reset}              Afficher cette aide
-  ${COLORS.cyan}version${COLORS.reset}           Afficher la version
-
-${COLORS.bright}OPTIONS${COLORS.reset}
-  -c, --config        Chemin vers le fichier de configuration
-  -o, --output        Dossier de sortie
-  -p, --port          Port du serveur de développement (défaut: 3000)
-  -w, --watch         Surveiller les changements (alias de dev)
-  -v, --verbose       Mode verbeux
-  -q, --quiet         Mode silencieux
-  --no-color          Désactiver les couleurs
-
-${COLORS.bright}EXEMPLES${COLORS.reset}
-  ${COLORS.dim}# Initialiser un projet${COLORS.reset}
-  ether init
-
-  ${COLORS.dim}# Compiler le projet${COLORS.reset}
-  ether build
-
-  ${COLORS.dim}# Mode développement sur localhost:3000${COLORS.reset}
-  ether dev
-
-  ${COLORS.dim}# Mode développement sur un autre port${COLORS.reset}
-  ether dev -p 8080
-
-${COLORS.bright}DOCUMENTATION${COLORS.reset}
-  https://ether-code.com/docs
-`)
-}
-
-function showVersion() {
-  console.log(`Ether v${VERSION}`)
-}
-
-function loadConfig(configPath) {
-  const defaultConfig = {
-    src: './src',
-    out: './dist',
-    targets: {},
-    i18n: 'fr',
-    watch: {
-      ignored: ['node_modules', '.git', 'dist']
-    }
-  }
-
-  const configFile = configPath || path.join(process.cwd(), 'ether.config.js')
-  
-  if (fs.existsSync(configFile)) {
-    try {
-      const userConfig = require(configFile)
-      return { ...defaultConfig, ...userConfig }
-    } catch (err) {
-      logError(`Erreur de configuration: ${err.message}`)
-      return defaultConfig
-    }
-  }
-  
-  const jsonConfig = path.join(process.cwd(), 'ether.config.json')
-  if (fs.existsSync(jsonConfig)) {
-    try {
-      const content = fs.readFileSync(jsonConfig, 'utf-8')
-      const userConfig = JSON.parse(content)
-      return { ...defaultConfig, ...userConfig }
-    } catch (err) {
-      logError(`Erreur de configuration: ${err.message}`)
-      return defaultConfig
-    }
-  }
-
-  return defaultConfig
-}
-
-async function cmdInit() {
-  showBanner()
-  logInfo('Initialisation du projet Ether...')
-  
-  const cwd = process.cwd()
-  
-  const srcDir = path.join(cwd, 'src')
-  if (!fs.existsSync(srcDir)) {
-    fs.mkdirSync(srcDir, { recursive: true })
-    logSuccess('Dossier src/ créé')
-  }
-
-  const publicDir = path.join(cwd, 'public')
-  if (!fs.existsSync(publicDir)) {
-    fs.mkdirSync(publicDir, { recursive: true })
-    logSuccess('Dossier public/ créé')
-  }
-
-  const imagesDir = path.join(publicDir, 'images')
-  if (!fs.existsSync(imagesDir)) {
-    fs.mkdirSync(imagesDir, { recursive: true })
-    logSuccess('Dossier public/images/ créé')
-  }
-
-  const videosDir = path.join(publicDir, 'videos')
-  if (!fs.existsSync(videosDir)) {
-    fs.mkdirSync(videosDir, { recursive: true })
-    logSuccess('Dossier public/videos/ créé')
-  }
-
-  const configContent = `module.exports = {
-  src: './src',
-  out: './dist',
-  
-  i18n: 'fr',
-  
-  targets: {
-    css: {
-      extension: '.css',
-      minify: false
-    },
-    html: {
-      extension: '.html',
-      minify: false
-    },
-    js: {
-      extension: '.js',
-      minify: false
-    }
-  },
-  
-  watch: {
-    ignored: ['node_modules', '.git', 'dist']
-  }
-}
-`
-
-  const configPath = path.join(cwd, 'ether.config.js')
-  if (!fs.existsSync(configPath)) {
-    fs.writeFileSync(configPath, configContent)
-    logSuccess('Fichier ether.config.js créé')
-  } else {
-    logWarning('ether.config.js existe déjà')
-  }
-
-  const projectName = path.basename(cwd)
-  const packageJson = {
-    name: projectName,
-    version: "1.0.0",
-    description: "Projet Ether",
-    scripts: {
-      dev: "ether dev",
-      build: "ether build",
-      check: "ether check"
-    },
-    keywords: ["ether"],
-    license: "MIT"
-  }
-
-  const packagePath = path.join(cwd, 'package.json')
-  if (!fs.existsSync(packagePath)) {
-    fs.writeFileSync(packagePath, JSON.stringify(packageJson, null, 2))
-    logSuccess('Fichier package.json créé')
-  } else {
-    logWarning('package.json existe déjà')
-  }
-
-  const exampleEth = `html
-  tête
-    titre "Ma première page Ether"
-  corps
-    entete
-      titre1 "Bienvenue sur Ether"
-      paragraphe "Le langage intentionnel"
-    principal
-      section #hero
-        titre2 "Commencez maintenant"
-        paragraphe "Programmez dans votre langue naturelle."
-        bouton .primary "Démarrer"
-    pied
-      paragraphe "© 2025 Créé avec Ether"
-`
-
-  const examplePath = path.join(srcDir, 'index.eth')
-  if (!fs.existsSync(examplePath)) {
-    fs.writeFileSync(examplePath, exampleEth)
-    logSuccess('Fichier exemple src/index.eth créé')
-  }
-
-  console.log('')
-  logSuccess('Projet initialisé avec succès!')
-  console.log('')
-  logInfo('Prochaines étapes:')
-  console.log(`  1. Éditer ${COLORS.cyan}src/index.eth${COLORS.reset}`)
-  console.log(`  2. Lancer ${COLORS.cyan}ether dev${COLORS.reset} pour le mode développement`)
-  console.log(`  3. Ou ${COLORS.cyan}ether build${COLORS.reset} pour compiler`)
-  console.log('')
-}
-
-async function cmdBuild(options) {
-  const startTime = Date.now()
-  
-  if (!options.quiet) {
-    showBanner()
-    logInfo('Compilation en cours...')
-    console.log('')
-  }
-  
-  const config = loadConfig(options.config)
-  const srcDir = path.resolve(process.cwd(), config.src)
-  const outDir = path.resolve(process.cwd(), options.output || config.out)
-  const publicDir = path.resolve(process.cwd(), config.public || 'public')
-  
-  if (!fs.existsSync(srcDir)) {
-    logError(`Dossier source introuvable: ${srcDir}`)
-    process.exit(1)
-  }
-  
-  if (!fs.existsSync(outDir)) {
-    fs.mkdirSync(outDir, { recursive: true })
-  }
-  
-  if (fs.existsSync(publicDir)) {
-    copyDir(publicDir, outDir)
-    if (!options.quiet) {
-      logSuccess('Dossier public/ copié vers dist/')
-    }
-  }
-  
-  const compiler = new EtherCompiler(config)
-  
-  const files = findEthFiles(srcDir)
-  
-  if (files.length === 0) {
-    logWarning('Aucun fichier .eth trouvé')
-    return
-  }
-  
-  let successCount = 0
-  let errorCount = 0
-  
-  for (const file of files) {
-    try {
-      const relativePath = path.relative(srcDir, file)
-      const result = await compiler.compileFile(file)
-      
-      for (const output of result.outputs) {
-        const outPath = path.join(outDir, output.path)
-        const outDirPath = path.dirname(outPath)
-        
-        if (!fs.existsSync(outDirPath)) {
-          fs.mkdirSync(outDirPath, { recursive: true })
-        }
-        
-        fs.writeFileSync(outPath, output.content)
-        
-        if (options.verbose) {
-          logSuccess(`${relativePath} → ${output.path}`)
-        }
-      }
-      
-      successCount++
-    } catch (err) {
-      errorCount++
-      logError(`${path.relative(srcDir, file)}: ${err.message}`)
-      
-      if (options.verbose) {
-        console.error(err.stack)
-      }
-    }
-  }
-  
-  const duration = Date.now() - startTime
-  
-  console.log('')
-  if (errorCount === 0) {
-    logSuccess(`${successCount} fichier(s) compilé(s) en ${duration}ms`)
-  } else {
-    logWarning(`${successCount} succès, ${errorCount} erreur(s) en ${duration}ms`)
-  }
-}
-
-async function cmdDev(options) {
-  showBanner()
-  
-  const config = loadConfig(options.config)
-  const srcDir = path.resolve(process.cwd(), config.src)
-  const outDir = path.resolve(process.cwd(), options.output || config.out)
-  const port = options.port || config.port || 3000
-  
-  if (!fs.existsSync(srcDir)) {
-    logError(`Dossier source introuvable: ${srcDir}`)
-    process.exit(1)
-  }
-  
-  logInfo(`Surveillance de ${srcDir}`)
-  logInfo(`Sortie vers ${outDir}`)
-  console.log('')
-  
-  await cmdBuild({ ...options, quiet: true })
-  
-  const clients = []
-  
-  const MIME_TYPES = {
-    '.html': 'text/html',
-    '.css': 'text/css',
-    '.js': 'application/javascript',
-    '.json': 'application/json',
-    '.png': 'image/png',
-    '.jpg': 'image/jpeg',
-    '.jpeg': 'image/jpeg',
-    '.gif': 'image/gif',
-    '.svg': 'image/svg+xml',
-    '.ico': 'image/x-icon',
-    '.webp': 'image/webp',
-    '.mp4': 'video/mp4',
-    '.webm': 'video/webm',
-    '.woff': 'font/woff',
-    '.woff2': 'font/woff2',
-    '.ttf': 'font/ttf'
-  }
-  
-  const LIVE_RELOAD_SCRIPT = `
-<script>
-(function() {
-  const es = new EventSource('/__ether_reload');
-  es.onmessage = function(e) {
-    if (e.data === 'reload') {
-      window.location.reload();
-    }
-  };
-  es.onerror = function() {
-    es.close();
-    setTimeout(function() { window.location.reload(); }, 1000);
-  };
-})();
-</script>
-</body>`
-  
-  const server = http.createServer((req, res) => {
-    if (req.url === '/__ether_reload') {
-      res.writeHead(200, {
-        'Content-Type': 'text/event-stream',
-        'Cache-Control': 'no-cache',
-        'Connection': 'keep-alive',
-        'Access-Control-Allow-Origin': '*'
-      })
-      res.write('data: connected\n\n')
-      clients.push(res)
-      req.on('close', () => {
-        const index = clients.indexOf(res)
-        if (index > -1) clients.splice(index, 1)
-      })
-      return
-    }
-    
-    let filePath = req.url === '/' ? '/index.html' : req.url
-    filePath = filePath.split('?')[0]
-    filePath = path.join(outDir, filePath)
-    
-    const ext = path.extname(filePath).toLowerCase()
-    const contentType = MIME_TYPES[ext] || 'application/octet-stream'
-    
-    fs.readFile(filePath, (err, content) => {
-      if (err) {
-        if (err.code === 'ENOENT') {
-          res.writeHead(404)
-          res.end('404 - Fichier non trouvé')
-        } else {
-          res.writeHead(500)
-          res.end('Erreur serveur')
-        }
-        return
-      }
-      
-      if (ext === '.html') {
-        content = content.toString().replace('</body>', LIVE_RELOAD_SCRIPT)
-      }
-      
-      res.writeHead(200, { 'Content-Type': contentType })
-      res.end(content)
-    })
-  })
-  
-  server.listen(port, () => {
-    logSuccess(`Serveur démarré sur http://localhost:${port}`)
-    console.log('')
-    logInfo('En attente de modifications... (Ctrl+C pour arrêter)')
-    console.log('')
-  })
-  
-  function notifyClients() {
-    clients.forEach(client => {
-      client.write('data: reload\n\n')
-    })
-  }
-  
-  const watcher = new Watcher(srcDir, config.watch)
-  const compiler = new EtherCompiler(config)
-  
-  watcher.on('change', async (filePath) => {
-    if (!filePath.endsWith('.eth')) return
-    
-    const relativePath = path.relative(srcDir, filePath)
-    logInfo(`Modification: ${relativePath}`)
-    
-    try {
-      const result = await compiler.compileFile(filePath)
-      
-      for (const output of result.outputs) {
-        const outPath = path.join(outDir, output.path)
-        const outDirPath = path.dirname(outPath)
-        
-        if (!fs.existsSync(outDirPath)) {
-          fs.mkdirSync(outDirPath, { recursive: true })
-        }
-        
-        fs.writeFileSync(outPath, output.content)
-        logSuccess(`→ ${output.path}`)
-      }
-      
-      notifyClients()
-    } catch (err) {
-      logError(err.message)
-    }
-  })
-  
-  watcher.on('add', async (filePath) => {
-    if (!filePath.endsWith('.eth')) return
-    
-    const relativePath = path.relative(srcDir, filePath)
-    logInfo(`Nouveau fichier: ${relativePath}`)
-    
-    try {
-      const result = await compiler.compileFile(filePath)
-      
-      for (const output of result.outputs) {
-        const outPath = path.join(outDir, output.path)
-        const outDirPath = path.dirname(outPath)
-        
-        if (!fs.existsSync(outDirPath)) {
-          fs.mkdirSync(outDirPath, { recursive: true })
-        }
-        
-        fs.writeFileSync(outPath, output.content)
-        logSuccess(`→ ${output.path}`)
-      }
-      
-      notifyClients()
-    } catch (err) {
-      logError(err.message)
-    }
-  })
-  
-  watcher.on('unlink', (filePath) => {
-    if (!filePath.endsWith('.eth')) return
-    logWarning(`Fichier supprimé: ${path.relative(srcDir, filePath)}`)
-  })
-  
-  watcher.start()
-  
-  process.on('SIGINT', () => {
-    console.log('')
-    logInfo('Arrêt du serveur de développement')
-    server.close()
-    watcher.stop()
-    process.exit(0)
-  })
-}
-
-async function cmdCheck(options) {
-  showBanner()
-  logInfo('Vérification de la syntaxe...')
-  console.log('')
-  
-  const config = loadConfig(options.config)
-  const srcDir = path.resolve(process.cwd(), config.src)
-  
-  if (!fs.existsSync(srcDir)) {
-    logError(`Dossier source introuvable: ${srcDir}`)
-    process.exit(1)
-  }
-  
-  const compiler = new EtherCompiler(config)
-  const files = findEthFiles(srcDir)
-  
-  if (files.length === 0) {
-    logWarning('Aucun fichier .eth trouvé')
-    return
-  }
-  
-  let validCount = 0
-  let errorCount = 0
-  
-  for (const file of files) {
-    const relativePath = path.relative(srcDir, file)
-    
-    try {
-      await compiler.check(file)
-      logSuccess(relativePath)
-      validCount++
-    } catch (err) {
-      logError(`${relativePath}: ${err.message}`)
-      errorCount++
-    }
-  }
-  
-  console.log('')
-  if (errorCount === 0) {
-    logSuccess(`${validCount} fichier(s) valide(s)`)
-  } else {
-    logError(`${errorCount} erreur(s) sur ${files.length} fichier(s)`)
-    process.exit(1)
-  }
-}
-
-function findEthFiles(dir) {
-  const files = []
-  
-  function scan(currentDir) {
-    const entries = fs.readdirSync(currentDir, { withFileTypes: true })
-    
-    for (const entry of entries) {
-      const fullPath = path.join(currentDir, entry.name)
-      
-      if (entry.isDirectory()) {
-        if (!['node_modules', '.git', 'dist'].includes(entry.name)) {
-          scan(fullPath)
-        }
-      } else if (entry.name.endsWith('.eth')) {
-        files.push(fullPath)
-      }
-    }
-  }
-  
-  scan(dir)
-  return files
-}
-
-function copyDir(src, dest) {
-  if (!fs.existsSync(dest)) {
-    fs.mkdirSync(dest, { recursive: true })
-  }
-  
-  const entries = fs.readdirSync(src, { withFileTypes: true })
-  
-  for (const entry of entries) {
-    const srcPath = path.join(src, entry.name)
-    const destPath = path.join(dest, entry.name)
-    
-    if (entry.isDirectory()) {
-      copyDir(srcPath, destPath)
-    } else {
-      fs.copyFileSync(srcPath, destPath)
-    }
-  }
-}
-
-function parseArgs(args) {
-  const options = {
-    command: null,
-    config: null,
-    output: null,
-    port: null,
-    verbose: false,
-    quiet: false,
-    watch: false
-  }
-  
-  let i = 0
-  while (i < args.length) {
-    const arg = args[i]
-    
-    if (arg === '-c' || arg === '--config') {
-      options.config = args[++i]
-    } else if (arg === '-o' || arg === '--output') {
-      options.output = args[++i]
-    } else if (arg === '-p' || arg === '--port') {
-      options.port = parseInt(args[++i], 10)
-    } else if (arg === '-v' || arg === '--verbose') {
-      options.verbose = true
-    } else if (arg === '-q' || arg === '--quiet') {
-      options.quiet = true
-    } else if (arg === '-w' || arg === '--watch') {
-      options.watch = true
-    } else if (arg === '--no-color') {
-      for (const key in COLORS) {
-        COLORS[key] = ''
-      }
-    } else if (!arg.startsWith('-')) {
-      if (!options.command) {
-        options.command = arg
-      }
-    }
-    
-    i++
-  }
-  
-  return options
-}
-
-async function main() {
-  const args = process.argv.slice(2)
-  const options = parseArgs(args)
-  
-  if (options.watch && !options.command) {
-    options.command = 'dev'
-  }
-  
-  switch (options.command) {
-    case 'init':
-      await cmdInit()
-      break
-    case 'build':
-      await cmdBuild(options)
-      break
-    case 'dev':
-    case 'watch':
-      await cmdDev(options)
-      break
-    case 'check':
-      await cmdCheck(options)
-      break
-    case 'version':
-    case '-V':
-    case '--version':
-      showVersion()
-      break
-    case 'help':
-    case '-h':
-    case '--help':
-    default:
-      showHelp()
-      break
-  }
-}
-
-main().catch(err => {
-  logError(err.message)
-  process.exit(1)
-})