xanascript 2.0.0

package/README.md

@@ -0,0 +1,132 @@
+# XanaScript
+
+Program in Portuguese. Run on WebAssembly. Real performance.
+
+XanaScript is a programming language with Portuguese syntax, optimizing compiler (JavaScript + WebAssembly), built-in ORM, compile-time macros, LSP, and zero runtime dependencies.
+
+```bash
+npm install -g xanascript
+xs run app.xs
+```
+
+```xs
+PARTIU()
+CHAMA ESSE CARA fib(n) {
+  SE LIGA SO (n <= 1) { VOLTA n }
+  VOLTA fib(n - 1) + fib(n - 2)
+}
+SOLTA O GRITO("fib(10) =", fib(10))
+ACABOU()
+```
+
+---
+
+## Quick Start
+
+```bash
+# Via npm (requires Node.js)
+npm install -g xanascript
+xs run app.xs
+
+# Via source
+git clone https://github.com/xanascr/xs.git
+cd xs
+npm install
+node src/cli.js run app.xs
+
+# Native binary (requires bun)
+npm run build
+dist/xs run app.xs
+```
+
+## Documentation
+
+- [Full documentation](docs/en/getting-started.md) - English
+- [Documentacao completa](docs/pt-br/comecando.md) - Portugues
+- [Documentacion completa](docs/es/introduccion.md) - Espanol
+- [Examples](https://github.com/xanascr/xs-examples)
+- [Installer](https://github.com/xanascr/xs-installer)
+- [VS Code Extension](https://github.com/xanascr/xs-vscode)
+- [LLM Reference](llms.txt) - Complete reference for AI assistants
+
+## Architecture
+
+```
+.xs source  ->  Lexer  ->  Parser  ->  Optimizer  ->  Codegen (JS / Wasm)
+                                                       -> Runtime (interpreter)
+```
+
+| Module | File | Purpose |
+|--------|------|---------|
+| Lexer | `src/lexer.js` | Tokenization with line/col tracking |
+| Parser | `src/parser.js` | AST generation |
+| Optimizer | `src/optimizer.js` | Macros, constant folding, dead branches |
+| Interpreter | `src/interpreter.js` | AST walking interpreter |
+| Runtime | `src/runtime.js` | Built-ins and environment |
+| Codegen JS | `src/codegen.js` | JavaScript generation |
+| Codegen Opt | `src/codegen_opt.js` | Optimized JS (TypedArrays, int32) |
+| Codegen Wasm | `src/codegen_wasm.js` | WebAssembly text format |
+| Wasm Binary | `src/wasm_binary.js` | Direct Wasm binary (no wabt.js) |
+| Errors | `src/errors.js` | Rust-style error reporting |
+| CLI | `src/cli.js` | Command-line interface |
+| ORM | `src/orm.js` | Built-in ORM (TABLE -> CRUD) |
+| Macros | `src/macros.js` | Compile-time expansion |
+| LSP | `src/lsp.js` | Language Server Protocol |
+| Test Runner | `src/testrunner.js` | Native test runner |
+| Docs Gen | `src/docsgen.js` | HTML documentation generator |
+| Pkg Manager | `src/pkgmgr.js` | Package manager |
+| Source Map | `src/sourcemap.js` | Source maps |
+| Bytecode VM | `src/bytecode/` | Stack-based VM |
+
+## CLI
+
+```
+xs run <file>         Execute .xs
+xs check <file>       Check syntax
+xs build <file>       Generate JavaScript
+xs build --opt <file> Optimized JavaScript
+xs build --wasm <file> WebAssembly
+xs build --standalone Single JS with runtime
+xs test .             Run tests
+xs dev <file>         Hot reload
+xs repl               Interactive mode
+xs lsp                Language Server
+xs fmt <file>         Format code
+xs docs src/ docs/    HTML documentation
+xs init <name>        New project
+xs install <pkg>      Install package
+xs publish            Publish package
+xs bench              Benchmark
+xs vm <file>          Bytecode VM
+```
+
+## Tests
+
+```bash
+node test/lexer.test.js
+node test/parser.test.js
+node test/interpreter.test.js
+```
+
+## Structure
+
+```
+xs/
+  src/           Compiler (20 modules)
+  test/          Unit tests
+  std/           Standard library
+  scripts/       Build scripts
+  docs/          Documentation (en, pt-br, es)
+  package.json
+  VERSION
+```
+
+## Ecosystem
+
+| Repository | Description |
+|---|---|
+| [xanascript/xs](https://github.com/xanascr/xs) | Core language |
+| [xanascript/xs-site](https://github.com/xanascr/xs-site) | Website and documentation |
+| [xanascript/xs-vscode](https://github.com/xanascr/xs-vscode) | VS Code extension |
+| [xanascript/xs-examples](https://github.com/xanascr/xs-examples) | Code examples |
+| [xanascript/xs-installer](https://github.com/xanascr/xs-installer) | Windows installer |

package/VERSION

@@ -0,0 +1 @@
+2.0.0

package/llms.txt

@@ -0,0 +1,322 @@
+# XanaScript - LLM Documentation
+
+## Overview
+
+XanaScript is a programming language with Portuguese syntax, an optimizing compiler (JavaScript + WebAssembly), built-in ORM, compile-time macros, LSP, and zero runtime dependencies.
+
+- Repository: https://github.com/xanascr/xs
+- License: MIT
+- Language: Portuguese keywords, JavaScript/WebAssembly compilation target
+
+## Project Structure
+
+```
+xs/
+  src/           Compiler source (20 modules)
+  test/          Unit tests
+  std/           Standard library
+  scripts/       Build scripts
+  docs/          Documentation (en, pt-br, es)
+  package.json   npm package
+  VERSION        Version file
+```
+
+Key source files:
+
+| File | Purpose |
+|------|---------|
+| src/lexer.js | Tokenization with line/col tracking |
+| src/parser.js | AST generation via recursive descent |
+| src/ast.js | AST node constructors |
+| src/optimizer.js | Constant folding, dead branch elimination, macro expansion |
+| src/interpreter.js | AST-walking interpreter |
+| src/runtime.js | Built-in functions and execution environment |
+| src/codegen.js | Standard JavaScript code generation |
+| src/codegen_opt.js | Optimized JS with TypedArrays |
+| src/codegen_wasm.js | WebAssembly text format generation |
+| src/wasm_binary.js | Direct WebAssembly binary emission |
+| src/errors.js | Rust-style error formatting |
+| src/cli.js | CLI entry point |
+| src/orm.js | Built-in ORM |
+| src/macros.js | Compile-time macro expansion |
+| src/lsp.js | Language Server Protocol |
+| src/testrunner.js | Unit test runner |
+| src/docsgen.js | HTML documentation generator |
+| src/pkgmgr.js | Package manager |
+| src/sourcemap.js | Source map generation |
+| src/bytecode/compiler.js | Bytecode compiler |
+| src/bytecode/vm.js | Bytecode VM |
+| src/bytecode/opcodes.js | Opcode definitions |
+| src/bench.js | Benchmark runner |
+
+## Language Syntax
+
+### Program Structure
+
+All XanaScript programs are wrapped in PARTIU() / ACABOU():
+
+```xs
+PARTIU()
+  // code here
+ACABOU()
+```
+
+### Keywords
+
+```
+PARTIU, ACABOU, CRIA, SE, LIGA, SO, SENAO, REPETE, NA, MORAL, AI,
+CHAMA, ESSE, CARA, VOLTA, IMPORTA, EXPORTA, SOLTA, O, GRITO,
+FALA, BAIXO, AGORA, VAI, ESPERA, AI, SORTEIA, PARSEIA, OUVE, AQUI,
+VERDADEIRO, FALSO, NULO, TENTA, PEGA, ERRO, ASSINCRONO, VOA,
+CONTINUA, CLASSE, HERDA, CONSTRUTOR, ISTO, NOVA, METODO, ESCOLHE,
+CASO, PADRAO, COMBINA, SERVIDOR, PARA, TAMANHO, DIVIDE, TEXTO,
+ENCONTRA, DECODIFICA, URL, JUNTAR, TESTE, AFIRMA, ASSUNTO, TAREFA,
+TABELA, MACRO, TIPO, CRUD
+```
+
+### Data Types
+
+| Type | Examples |
+|------|----------|
+| Number | `10`, `3.14`, `-5` |
+| String | `"texto"`, `'texto'` |
+| Boolean | `VERDADEIRO`, `FALSO` |
+| Null | `NULO` |
+| Array | `[1, 2, 3]` |
+| Object | `{ nome: "Joao", idade: 30 }` |
+| Template | `` `Hello ${name}` `` |
+
+### Operators
+
+**Arithmetic:** `+` `-` `*` `/` `%`
+**Comparison:** `==` `!=` `>` `<` `>=` `<=` `~=`
+**Logical:** `&&` `||` `!`
+**Compound:** `+=` `-=` `*=` `/=` `%=`
+**Ternary:** `test ? cons : alt`
+
+### Variables
+
+```xs
+CRIA x = 10
+CRIA nome = "Maria"
+CRIA ativo = VERDADEIRO
+CRIA valor = NULO
+```
+
+### Control Flow
+
+**If/Else:**
+```xs
+SE LIGA SO (cond) { } SENAO { }
+SENAO SE LIGA SO (cond) { }
+```
+
+**While:**
+```xs
+REPETE AI (cond) { }
+```
+
+**For:**
+```xs
+REPETE NA MORAL (init; test; update) { }
+```
+
+**Break/Continue:**
+```xs
+VOA()     // break
+CONTINUA() // continue
+```
+
+**Switch:**
+```xs
+ESCOLHE (expr) {
+  CASO valor: code
+  PADRAO: code
+}
+```
+
+**Pattern Matching:**
+```xs
+COMBINA (expr) {
+  CASO pattern: code
+  CASO _: code
+}
+```
+
+### Functions
+
+```xs
+CHAMA ESSE CARA nome(params) { }
+VOLTA expr
+```
+
+Arrow functions:
+```xs
+(params) => expr
+(params) => { }
+ASSINCRONO (params) => { }
+```
+
+### Classes / OOP
+
+```xs
+CLASSE Nome {
+  CONSTRUTOR(params) { }
+  METODO nome(params) { }
+}
+CLASSE Filha HERDA Pai { }
+ISTO    // this
+NOVA Classe() // new
+```
+
+### Error Handling
+
+```xs
+TENTA { } PEGA(erro) { }
+```
+
+### Modules
+
+```xs
+IMPORTA "path"
+IMPORTA "path" as alias
+IMPORTA nome
+EXPORTA nome
+```
+
+### Macros (Compile-time)
+
+```xs
+MACRO nome(params) { body }
+```
+
+### ORM
+
+```xs
+TABELA Nome { campo: TIPO }
+CRIA repo = TABELA("Nome")
+repo.criar(obj)
+repo.listar()
+repo.buscar(id)
+repo.atualizar(id, obj)
+repo.deletar(id)
+repo.buscarOnde(filter)
+repo.contar()
+```
+
+### Testing
+
+```xs
+TESTE("name") { AFIRMA(cond) }
+ASSUNTO(actual, expected)
+```
+
+### Tasks
+
+```xs
+TAREFA("name") { }
+```
+
+## Built-in Functions
+
+| Function | Description | Signature |
+|----------|-------------|-----------|
+| SOLTA_O_GRITO | Prints to stdout | SOLTA_O_GRITO(...args) |
+| FALA_BAIXO | Prints to stderr | FALA_BAIXO(...args) |
+| AGORA_VAI | HTTP GET request | AGORA_VAI(url) |
+| ESPERA_AI | Sleep/delay | ESPERA_AI(ms) |
+| SORTEIA | Random integer | SORTEIA(min, max) |
+| PARSEIA | JSON parse | PARSEIA(json) |
+| OUVE_AQUI | Environment variable | OUVE_AQUI(chave) |
+| TAMANHO | Length of array/string | TAMANHO(valor) |
+| DIVIDE_TEXTO | String split | DIVIDE_TEXTO(texto, separador) |
+| DECODIFICA_URL | URL decode | DECODIFICA_URL(url) |
+| CRIA_SERVIDOR | HTTP server | CRIA_SERVIDOR(porta, handler) |
+| PARA_SERVIDOR | Stop server | PARA_SERVIDOR(server) |
+
+## CLI Commands
+
+```
+xs run <file>         Execute .xs file (AST Interpreter)
+xs vm <file>          Execute .xs file (Bytecode VM)
+xs check <file>       Check syntax only
+xs build <file>       Generate JavaScript
+xs build --opt <file> Generate optimized JavaScript
+xs build --wasm <file>Generate WebAssembly (.wat + .wasm)
+xs build --standalone <file> Generate single .js with runtime
+xs test <dir>         Run test files
+xs dev <file>         Watch mode with hot reload
+xs fmt <file>         Format .xs file
+xs repl               Interactive REPL
+xs lsp                Language Server Protocol (stdin/stdout)
+xs docs <src> <out>   Generate HTML documentation
+xs init <name>        Create new project scaffold
+xs install <pkg>      Install a package
+xs publish            Publish current package
+xs bench              Run benchmarks
+```
+
+## Compilation Pipeline
+
+```
+.xs source  ->  Lexer  ->  Parser  ->  Optimizer  ->  Codegen -> Output
+                                                       |-> JS
+                                                       |-> Opt JS (TypedArrays)
+                                                       |-> Wasm text
+                                                       |-> Wasm binary
+                                                       |-> Bytecode -> VM
+```
+
+1. **Lexer** (lexer.js): Converts source text to tokens with position tracking
+2. **Parser** (parser.js): Recursive descent parser, generates AST
+3. **Optimizer** (optimizer.js): Constant folding, dead branch elimination, macro expansion
+4. **Code Generation**: Multiple backends
+   - codegen.js: Standard JavaScript
+   - codegen_opt.js: Optimized JS with int32 TypedArrays
+   - codegen_wasm.js: WebAssembly text (.wat) format
+   - wasm_binary.js: Direct binary Wasm emission
+   - bytecode/compiler.js + bytecode/vm.js: Stack-based bytecode
+
+## Error System
+
+Rust-style errors with source code preview, arrow pointing to exact location, and hints:
+
+```
+  XSError: message
+    --> file.xs:line:col
+  1 | code
+    | ^
+  hint: suggestion
+```
+
+Error codes: E001-E005, E999, I001
+
+## Bytecode VM (26 opcodes)
+
+Opcodes include: PUSH, POP, ADD, SUB, MUL, DIV, MOD, EQ, NEQ, GT, LT, GTE, LTE, AND, OR, NOT, NEG, JMP, JIF, LOAD, STORE, CALL, RET, PRN, NEWA, NEWO, LDAT, STAT, DUP, SWAP, HALT
+
+## ORM (Object-Relational Mapping)
+
+SQLite-backed repository with JSON file storage. Field types: TEXTO, NUMERO, BOOLEANO, DATA. Data stored in `.xs-data/` directory.
+
+## LSP (Language Server Protocol)
+
+Provides autocomplete, hover information, go-to-definition, diagnostics, and signature help via stdin/stdout.
+
+## Package Manager
+
+Registry: https://api.xanascript.dev/packages
+Fallback: npm with `xanascript-` prefix
+Commands: xs init, xs install, xs publish
+
+## Source Maps
+
+VLQ-encoded source mappings between generated JS and original .xs lines. Comment format: `//# sourceMappingURL=data:application/json;base64,...`
+
+## Build Process
+
+Requires bun for native compilation:
+```bash
+node scripts/build-all.js
+```
+Outputs standalone binary `dist/xs(.exe)` with zero dependencies. Bundles all 147 modules into single executable.

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "xanascript",
+  "version": "2.0.0",
+  "description": "Programming language with Portuguese syntax, optimizing compiler, built-in ORM, and WebAssembly support",
+  "type": "module",
+  "bin": {
+    "xs": "./src/cli.js"
+  },
+  "scripts": {
+    "build": "node scripts/build-all.js",
+    "test": "node test/lexer.test.js && node test/parser.test.js && node test/interpreter.test.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/xanascr/xs.git"
+  },
+  "keywords": ["xanascript", "language", "portuguese", "programming", "compiler", "wasm"],
+  "author": "XanaScript",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/xanascr/xs/issues"
+  },
+  "homepage": "https://xanascript.xyz",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "src",
+    "std",
+    "llms.txt",
+    "VERSION"
+  ]
+}

package/src/ast.js

@@ -0,0 +1,65 @@
+let _loc = null;
+export function setLoc(loc) { _loc = loc; }
+
+function loc() {
+  const l = _loc;
+  _loc = null;
+  return l;
+}
+
+export const Program = body => ({ type: "Program", body, loc: loc() });
+export const VarDecl = (id, init, typeHint) => ({ type: "VarDecl", id, init, typeHint, loc: loc() });
+export const Assign = (left, right) => ({ type: "Assign", left, right, loc: loc() });
+export const Binary = (op, left, right) => ({ type: "Binary", op, left, right, loc: loc() });
+export const Unary = (op, arg) => ({ type: "Unary", op, arg, loc: loc() });
+export const IfStmt = (test, cons, alt) => ({ type: "IfStmt", test, cons, alt, loc: loc() });
+export const ForStmt = (init, test, update, body) => ({ type: "ForStmt", init, test, update, body, loc: loc() });
+export const Block = body => ({ type: "Block", body, loc: loc() });
+export const Call = (callee, args) => ({ type: "Call", callee, args, loc: loc() });
+export const Member = (obj, prop) => ({ type: "Member", obj, prop, loc: loc() });
+export const FunctionDecl = (name, params, body) => ({ type: "FunctionDecl", name, params, body, loc: loc() });
+export const ReturnStmt = arg => ({ type: "ReturnStmt", arg, loc: loc() });
+export const ExportStmt = name => ({ type: "ExportStmt", name, loc: loc() });
+export const ImportExpr = path => ({ type: "ImportExpr", path, loc: loc() });
+export const Ident = name => ({ type: "Ident", name, loc: loc() });
+export const Num = value => ({ type: "Num", value, loc: loc() });
+export const Str = value => ({ type: "Str", value, loc: loc() });
+export const Bool = value => ({ type: "Bool", value, loc: loc() });
+export const Nil = () => ({ type: "Nil", loc: loc() });
+export const ArrayExpr = (items) => ({ type: "ArrayExpr", items, loc: loc() });
+export const ObjectExpr = (props) => ({ type: "ObjectExpr", props, loc: loc() });
+export const ArrowFunction = (params, body, isAsync = false) => ({ type: "ArrowFunction", params, body, isAsync, loc: loc() });
+export const TryCatchStmt = (tryBlock, catchParam, catchBlock) => ({ type: "TryCatchStmt", tryBlock, catchParam, catchBlock, loc: loc() });
+export const IndexExpr = (obj, index) => ({ type: "IndexExpr", obj, index, loc: loc() });
+export const ImportStmt = (path, alias) => ({ type: "ImportStmt", path, alias, loc: loc() });
+export const WhileStmt = (test, body) => ({ type: "WhileStmt", test, body, loc: loc() });
+export const BreakStmt = () => ({ type: "BreakStmt", loc: loc() });
+export const ContinueStmt = () => ({ type: "ContinueStmt", loc: loc() });
+export const Ternary = (test, cons, alt) => ({ type: "Ternary", test, cons, alt, loc: loc() });
+
+export const ClassDecl = (name, superClass, methods) => ({ type: "ClassDecl", name, superClass, methods, loc: loc() });
+export const Method = (name, params, body, isConstructor) => ({ type: "Method", name, params, body, isConstructor, loc: loc() });
+export const ThisExpr = () => ({ type: "ThisExpr", loc: loc() });
+export const NewExpr = (callee, args) => ({ type: "NewExpr", callee, args, loc: loc() });
+
+export const SwitchStmt = (test, cases) => ({ type: "SwitchStmt", test, cases, loc: loc() });
+export const SwitchCase = (test, body) => ({ type: "SwitchCase", test, body, loc: loc() });
+
+export const MatchExpr = (test, cases) => ({ type: "MatchExpr", test, cases, loc: loc() });
+export const MatchCase = (pattern, body, guard) => ({ type: "MatchCase", pattern, body, guard, loc: loc() });
+export const PatternLiteral = value => ({ type: "PatternLiteral", value, loc: loc() });
+export const PatternIdent = name => ({ type: "PatternIdent", name, loc: loc() });
+export const PatternArray = (elements) => ({ type: "PatternArray", elements, loc: loc() });
+export const PatternObject = (props) => ({ type: "PatternObject", props, loc: loc() });
+export const PatternRest = () => ({ type: "PatternRest", loc: loc() });
+export const PatternGuard = (expr) => ({ type: "PatternGuard", expr, loc: loc() });
+
+export const TestStmt = (name, body) => ({ type: "TestStmt", name, body, loc: loc() });
+export const AssertStmt = (test, expected) => ({ type: "AssertStmt", test, expected, loc: loc() });
+
+export const TaskDecl = (name, body) => ({ type: "TaskDecl", name, body, loc: loc() });
+
+export const TableDecl = (name, props) => ({ type: "TableDecl", name, props, loc: loc() });
+export const TableProp = (name, type) => ({ name, type, loc: loc() });
+
+export const MacroDecl = (name, params, body) => ({ type: "MacroDecl", name, params, body, loc: loc() });

package/src/bench.js

@@ -0,0 +1,68 @@
+import { lex } from "./lexer.js";
+import { parse } from "./parser.js";
+import { optimize } from "./optimizer.js";
+import { runXS } from "./runtime.js";
+
+export async function runBench() {
+  console.log("\n XanaScript Benchmark\n");
+
+  const xsCode = `
+CHAMA ESSE CARA fib(n) {
+  SE LIGA SO (n <= 1) {
+    VOLTA n
+  }
+  VOLTA fib(n - 1) + fib(n - 2)
+}
+fib(20)
+`;
+
+  const jsCode = `
+function fib(n) {
+  if (n <= 1) return n;
+  return fib(n - 1) + fib(n - 2);
+}
+fib(20)
+`;
+
+  const ITERATIONS = 3;
+
+  for (let i = 0; i < 2; i++) {
+    await runXS(xsCode);
+    eval(jsCode);
+  }
+
+  let xsTotal = 0;
+  for (let i = 0; i < ITERATIONS; i++) {
+    const start = performance.now();
+    await runXS(xsCode);
+    xsTotal += performance.now() - start;
+  }
+
+  let jsTotal = 0;
+  for (let i = 0; i < ITERATIONS; i++) {
+    const start = performance.now();
+    eval(jsCode);
+    jsTotal += performance.now() - start;
+  }
+
+  const xsAvg = (xsTotal / ITERATIONS).toFixed(2);
+  const jsAvg = (jsTotal / ITERATIONS).toFixed(2);
+  const ratio = (xsTotal / jsTotal).toFixed(2);
+
+  console.log(`  XanaScript: ${xsAvg}ms (avg)`);
+  console.log(`  JavaScript:  ${jsAvg}ms (avg)`);
+  console.log(`  Ratio:       ${ratio}x (${ratio > 1 ? "slower" : "faster"})`);
+
+  console.log("\n  --- Constant Folding ---");
+  const optCode = "CRIA x = 10 + 20 * 3 + (100 / 5)";
+  const tokens = lex(optCode);
+  let ast = parse(tokens);
+  ast = optimize(ast);
+  const folded = ast.body[0].init;
+  console.log(`  Input:  10 + 20 * 3 + (100 / 5)`);
+  console.log(`  Output: ${folded.value} (folded at compile time)`);
+  console.log(`  Savings: 4 operations eliminated\n`);
+
+  console.log("   XanaScript compiler eliminates constant expressions at compile-time,");
+  console.log("     something raw JS cannot do without a bundler.\n");
+}