ether-code 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Steve
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,130 @@
+# Ether
+
+**Le langage intentionnel** - Programmez dans votre langue naturelle.
+
+Ether est un compilateur qui transforme du code écrit en langage naturel (français, anglais, espagnol, russe, chinois, japonais) en code exécutable dans les langages cibles : JavaScript, TypeScript, HTML, CSS, PHP, Python, Ruby, SQL, Node.js, React, GraphQL.
+
+## Installation
+
+```bash
+npm install -g ether-lang
+```
+
+## Utilisation
+
+### Compiler un projet
+
+```bash
+ether build
+```
+
+### Mode développement (watch)
+
+```bash
+ether dev
+```
+
+### Compiler un fichier spécifique
+
+```bash
+ether build fichier.eth
+```
+
+## Configuration
+
+Créez un fichier `ether.config.json` à la racine de votre projet :
+
+```json
+{
+  "lang": "fr",
+  "src": "./src",
+  "out": "./dist",
+  "targets": ["js", "css", "html"]
+}
+```
+
+### Options
+
+| Option | Description | Défaut |
+|--------|-------------|--------|
+| `lang` | Langue source (fr, en, es, ru, zh, ja) | `fr` |
+| `src` | Dossier source | `./src` |
+| `out` | Dossier de sortie | `./dist` |
+| `targets` | Langages cibles | tous |
+
+## Exemple
+
+### Code Ether (français)
+
+```ether
+// style.eth
+sélecteur ".bouton"
+    couleur fond: bleu
+    couleur texte: blanc
+    marge: 1rem
+    bordure arrondie: 0.5rem
+```
+
+### Résultat CSS
+
+```css
+.bouton {
+    background-color: blue;
+    color: white;
+    margin: 1rem;
+    border-radius: 0.5rem;
+}
+```
+
+### Code Ether (JavaScript)
+
+```ether
+// app.eth
+fonction saluer avec nom
+    retourner "Bonjour, " + nom + "!"
+
+afficher saluer("Monde")
+```
+
+### Résultat JavaScript
+
+```javascript
+function saluer(nom) {
+    return "Bonjour, " + nom + "!";
+}
+
+console.log(saluer("Monde"));
+```
+
+## Langages supportés
+
+### Langues source
+- 🇫🇷 Français
+- 🇬🇧 English
+- 🇪🇸 Español
+- 🇷🇺 Русский
+- 🇨🇳 中文
+- 🇯🇵 日本語
+
+### Langages cibles
+- JavaScript / TypeScript
+- HTML / CSS
+- PHP
+- Python
+- Ruby
+- SQL
+- Node.js
+- React / JSX
+- GraphQL
+
+## Philosophie
+
+Ether est un **langage intentionnel** : au lieu de forcer les humains à parler comme des machines, Ether permet aux machines de comprendre l'intention humaine.
+
+- **Naturel** : Écrivez du code comme vous pensez
+- **Multilingue** : Programmez dans votre langue maternelle
+- **Universel** : Un seul langage, tous les frameworks
+
+## Licence
+
+MIT © Steve

package/cli/compiler.js

@@ -0,0 +1,298 @@
+const fs = require('fs')
+const path = require('path')
+
+const { EtherLexer } = require('../lexer/ether-lexer')
+
+const { CSSGenerator } = require('../generators/css-generator')
+const { HTMLGenerator } = require('../generators/html-generator')
+const { JSGenerator } = require('../generators/js-generator')
+const { PHPGenerator } = require('../generators/php-generator')
+const { SQLGenerator } = require('../generators/sql-generator')
+const { PythonGenerator } = require('../generators/python-generator')
+const { RubyGenerator } = require('../generators/ruby-generator')
+const { TSGenerator } = require('../generators/ts-generator')
+const { NodeGenerator } = require('../generators/node-generator')
+const { ReactGenerator } = require('../generators/react-generator')
+const { GraphQLGenerator } = require('../generators/graphql-generator')
+
+const GENERATORS = {
+  css: CSSGenerator,
+  html: HTMLGenerator,
+  js: JSGenerator,
+  javascript: JSGenerator,
+  php: PHPGenerator,
+  sql: SQLGenerator,
+  python: PythonGenerator,
+  py: PythonGenerator,
+  ruby: RubyGenerator,
+  rb: RubyGenerator,
+  ts: TSGenerator,
+  typescript: TSGenerator,
+  node: NodeGenerator,
+  nodejs: NodeGenerator,
+  react: ReactGenerator,
+  jsx: ReactGenerator,
+  graphql: GraphQLGenerator,
+  gql: GraphQLGenerator
+}
+
+const TARGET_EXTENSIONS = {
+  css: '.css',
+  html: '.html',
+  js: '.js',
+  javascript: '.js',
+  php: '.php',
+  sql: '.sql',
+  python: '.py',
+  py: '.py',
+  ruby: '.rb',
+  rb: '.rb',
+  ts: '.ts',
+  typescript: '.ts',
+  node: '.js',
+  nodejs: '.js',
+  react: '.jsx',
+  jsx: '.jsx',
+  graphql: '.graphql',
+  gql: '.graphql'
+}
+
+class EtherCompiler {
+  constructor(config = {}) {
+    this.config = {
+      i18n: 'fr',
+      targets: {},
+      ...config
+    }
+    
+    this.lexer = new EtherLexer()
+    this.generators = {}
+    this.parsers = {}
+    
+    this.initGenerators()
+  }
+
+  initGenerators() {
+    const i18nDir = path.join(__dirname, '..', 'i18n')
+    
+    for (const [target, GeneratorClass] of Object.entries(GENERATORS)) {
+      const i18nFile = path.join(i18nDir, `i18n-${this.normalizeTarget(target)}.json`)
+      
+      if (fs.existsSync(i18nFile)) {
+        this.generators[target] = new GeneratorClass(i18nFile)
+      } else {
+        this.generators[target] = new GeneratorClass()
+      }
+    }
+  }
+
+  normalizeTarget(target) {
+    const mappings = {
+      javascript: 'js',
+      typescript: 'ts',
+      nodejs: 'node',
+      python: 'python',
+      py: 'python',
+      ruby: 'ruby',
+      rb: 'ruby',
+      jsx: 'react',
+      gql: 'graphql'
+    }
+    return mappings[target] || target
+  }
+
+  async compileFile(filePath) {
+    const content = fs.readFileSync(filePath, 'utf-8')
+    const fileName = path.basename(filePath, '.eth')
+    const dirName = path.dirname(filePath)
+    
+    const target = this.detectTarget(content, filePath)
+    
+    const ast = this.parse(content, target)
+    
+    const code = this.generate(ast, target)
+    
+    const extension = this.getExtension(target)
+    const outputPath = `${fileName}${extension}`
+    
+    return {
+      source: filePath,
+      target,
+      outputs: [{
+        path: outputPath,
+        content: code
+      }]
+    }
+  }
+
+  parse(content, target) {
+    const lexer = new EtherLexer(content)
+    const tokens = lexer.tokenize()
+    
+    const normalizedTarget = this.normalizeTarget(target)
+    
+    try {
+      const ParserClass = this.loadParser(normalizedTarget)
+      if (ParserClass) {
+        const parser = new ParserClass(tokens, this.config)
+        return parser.parse()
+      }
+    } catch (err) {
+    }
+    
+    return this.buildGenericAST(tokens, target)
+  }
+
+  loadParser(target) {
+    try {
+      const parserPath = path.join(__dirname, '..', 'parsers', `${target}-parser.js`)
+      if (fs.existsSync(parserPath)) {
+        const module = require(parserPath)
+        const className = `${target.charAt(0).toUpperCase()}${target.slice(1)}Parser`
+        return module[className] || module.default || Object.values(module)[0]
+      }
+    } catch (err) {
+    }
+    return null
+  }
+
+  buildGenericAST(tokens, target) {
+    return {
+      type: 'Program',
+      target,
+      body: tokens.map(token => ({
+        type: 'Token',
+        tokenType: token.type,
+        value: token.value,
+        line: token.line,
+        column: token.column
+      }))
+    }
+  }
+
+  generate(ast, target) {
+    const normalizedTarget = this.normalizeTarget(target)
+    const generator = this.generators[normalizedTarget]
+    
+    if (!generator) {
+      throw new Error(`Générateur non trouvé pour la cible: ${target}`)
+    }
+    
+    return generator.generate(ast)
+  }
+
+  detectTarget(content, filePath) {
+    const directiveMatch = content.match(/^\/\/\s*(?:cible|target|@target)\s*:\s*(\w+)/im)
+    if (directiveMatch) {
+      return directiveMatch[1].toLowerCase()
+    }
+    
+    const commentMatch = content.match(/^\/\*\s*(?:cible|target)\s*:\s*(\w+)\s*\*\//im)
+    if (commentMatch) {
+      return commentMatch[1].toLowerCase()
+    }
+    
+    const hashMatch = content.match(/^#\s*(?:cible|target)\s*:\s*(\w+)/im)
+    if (hashMatch) {
+      return hashMatch[1].toLowerCase()
+    }
+    
+    const fileName = path.basename(filePath, '.eth')
+    const parts = fileName.split('.')
+    if (parts.length > 1) {
+      const ext = parts[parts.length - 1].toLowerCase()
+      if (GENERATORS[ext]) {
+        return ext
+      }
+    }
+    
+    return this.inferTargetFromContent(content)
+  }
+
+  inferTargetFromContent(content) {
+    const patterns = {
+      html: [
+        /\b(page|document|entête|corps|section|div|paragraphe|titre|lien|image|formulaire|bouton)\b/i,
+        /\b(balise|élément|attribut)\b/i
+      ],
+      css: [
+        /\b(style|couleur|taille|marge|bordure|fond|police|largeur|hauteur)\s*[:=]/i,
+        /\.([\w-]+)\s*\{/,
+        /#([\w-]+)\s*\{/
+      ],
+      js: [
+        /\b(fonction|variable|constante|si|sinon|pour|tant que|retourner)\b/i,
+        /\b(classe|méthode|constructeur)\b/i,
+        /=>\s*\{/
+      ],
+      php: [
+        /\b(<?php|echo|namespace|use)\b/i,
+        /\$\w+/
+      ],
+      sql: [
+        /\b(sélectionner|insérer|mettre à jour|supprimer|créer table|depuis|où)\b/i,
+        /\b(SELECT|INSERT|UPDATE|DELETE|CREATE|FROM|WHERE)\b/i
+      ],
+      python: [
+        /\b(def|class|import|from|if|elif|else|for|while|return)\b/,
+        /:\s*$/m
+      ],
+      react: [
+        /\b(composant|état|effet|props|rendu)\b/i,
+        /<[\w]+[^>]*\/>/
+      ],
+      graphql: [
+        /\b(type|query|mutation|subscription|schema|input)\b/i
+      ]
+    }
+    
+    for (const [target, patternList] of Object.entries(patterns)) {
+      for (const pattern of patternList) {
+        if (pattern.test(content)) {
+          return target
+        }
+      }
+    }
+    
+    return 'js'
+  }
+
+  getExtension(target) {
+    const normalizedTarget = this.normalizeTarget(target)
+    
+    if (this.config.targets[normalizedTarget]?.extension) {
+      return this.config.targets[normalizedTarget].extension
+    }
+    
+    return TARGET_EXTENSIONS[target] || TARGET_EXTENSIONS[normalizedTarget] || '.js'
+  }
+
+  async check(filePath) {
+    const content = fs.readFileSync(filePath, 'utf-8')
+    const target = this.detectTarget(content, filePath)
+    
+    try {
+      this.lexer.tokenize(content)
+    } catch (err) {
+      throw new Error(`Erreur de lexer: ${err.message}`)
+    }
+    
+    try {
+      this.parse(content, target)
+    } catch (err) {
+      throw new Error(`Erreur de syntaxe: ${err.message}`)
+    }
+    
+    return { valid: true, target }
+  }
+
+  getTargets() {
+    return Object.keys(GENERATORS)
+  }
+
+  getSupportedExtensions() {
+    return Object.entries(TARGET_EXTENSIONS)
+  }
+}
+
+module.exports = { EtherCompiler, GENERATORS, TARGET_EXTENSIONS }