vladx 1.5.1 → 1.6.1

package/.github/workflows/ci.yml

@@ -0,0 +1,20 @@
+name: VladX CI
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Use Node.js
+      uses: actions/setup-node@v3
+      with:
+        node-version: '18.x'
+    - run: npm install
+    - run: npm test

package/CHANGELOG.md

@@ -0,0 +1,14 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.5.1] - 2026-02-03
+### Added
+- Phase 0 of the roadmap: Baseline Hygiene.
+- Unified error handling base class `VladXError`.
+- Simple logging utility.
+- Project directory structure (`tests`, `benchmarks`, `docs`).
+- Initial CI workflow for GitHub Actions.
+- `CHANGELOG.md` to track project evolution.

package/examples/stdlib/tempo.vx

@@ -1,9 +1,8 @@
-importa { data, ora, pausa, timestamp } da "@std/Tempo";
+importa { data, ora } da "@std/Tempo";
 
 stampa("Oggi è il: " + data());
 stampa("Ora attuale: " + ora());
-stampa("Timestamp: " + timestamp());
 
 stampa("\nAttendo 1 secondo...");
-attendi pausa(1000);
+attendi aspetta(1000);
 stampa("Fine attesa.");

package/install.sh

@@ -25,11 +25,23 @@ echo "🌐 Installazione dell'ultima versione di Node.js..."
 nvm install node
 nvm use node
 
-# 3. Installazione VladX
+# 3. Preparazione directory VladX
+echo "📁 Preparazione directory dati (~/.vladx)..."
+mkdir -p "$HOME/.vladx/vladpm/bin"
+
+# 4. Installazione VladX
 echo "🛠️ Installazione globale di VladX e VladPM dal registry NPM..."
 
 npm install -g vladx
 
+# 5. Configurazione PATH
+echo "🌐 Configurazione PATH..."
+if [[ ":$PATH:" != *":$HOME/.vladx/vladpm/bin:"* ]]; then
+    echo 'export PATH="$HOME/.vladx/vladpm/bin:$PATH"' >> "$HOME/.bashrc"
+    echo "  ✓ Aggiunto ~/.vladx/vladpm/bin a .bashrc"
+    export PATH="$HOME/.vladx/vladpm/bin:$PATH"
+fi
+
 echo ""
 echo "✅ Installazione completata con successo!"
 echo "Node.js: $(node -v)"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vladx",
-  "version": "1.5.1",
+  "version": "1.6.1",
   "description": "VladX - Linguaggio di programmazione con sintassi italiana",
   "main": "src/index.js",
   "type": "commonjs",
@@ -10,7 +10,8 @@
   },
   "scripts": {
     "start": "node bin/vladx",
-    "repl": "node bin/vladx repl"
+    "repl": "node bin/vladx repl",
+    "postinstall": "node scripts/install-setup.js"
   },
   "keywords": [
     "language",

package/plan.md

@@ -0,0 +1,140 @@
+# VladX Roadmap to Node.js‑Level Capability
+
+This plan is an exhaustive, practical checklist to move VladX from a scripting interpreter toward a Node.js‑class runtime, ecosystem, and developer experience. It is intentionally ambitious and staged. “Node.js‑level” means a non‑blocking runtime, stable core APIs, a robust package ecosystem, strong tooling, security hardening, and measurable performance.
+
+## Principles
+- Preserve Italian syntax and identity while matching Node’s technical quality.
+- Prioritize correctness, security, and developer experience before performance optimizations.
+- Avoid breaking changes without clear migrations.
+- Automate quality gates early.
+
+## Phase 0 — Baseline Hygiene (Immediate)
+- Add a formal versioning strategy (SemVer + changelog).
+- Add a consistent error format with file/line/column everywhere.
+- Add a logging strategy for runtime and PM.
+- Create a repo directory standard for tests, benchmarks, and docs.
+- Add CI with linting, tests, and packaging validation.
+
+## Phase 1 — Correctness Fixes (Must‑Fix Bugs)
+- Fix file path resolution in `Archivio.*` to be relative to the executing file’s directory, not `..` from a file path.
+- Fix REPL last expression evaluation environment so it actually uses current scope.
+- Fix `new` parsing to accept `nuovo` on member expressions, not only identifiers.
+- Fix optional chaining support to include `obj?.[expr]` and `obj?.(args)`.
+- Add clear error when calling non‑functions, include actual type.
+- Ensure destructuring errors reference line/column and show expected vs received.
+- Resolve any mismatch between parser tokens and interpreter operators.
+- Clarify `async/await` semantics and ensure awaiting only actual promises.
+- Ensure `break/continue` are only valid inside loops/switch.
+- Ensure `return` is only valid inside functions.
+
+## Phase 2 — Real Async Runtime (Core Gap vs Node.js)
+- Replace all blocking I/O (`fs.readFileSync`, `execSync`, busy‑wait) with async equivalents.
+- Introduce an event loop abstraction with a task queue and microtask queue.
+- Implement timers (`setTimeout`, `setInterval`, `clearTimeout`, `clearInterval`).
+- Implement promises that integrate with the runtime, not only JS promises.
+- Implement async stack traces for awaited frames.
+- Add cancellation support (AbortController‑like).
+- Add async hooks to enable tracing and profiling.
+
+## Phase 3 — Module System Parity
+- Implement module caching with proper circular dependency handling.
+- Add support for package `main` and `exports` in `vladx.json`.
+- Add extension resolution rules that match Node’s behavior (configurable).
+- Add module resolution for relative, absolute, and bare specifiers with clear errors.
+- Add module type support (common vs esm‑like) or a single well‑defined model.
+- Add a standardized module loader for builtin modules and stdlib.
+
+## Phase 4 — Standard Library Modernization
+- Split stdlib into a clean, stable core API with versioning.
+- Replace `execSync` HTTP with a real HTTP client implementation.
+- Provide a `fetch`‑like API and streaming responses.
+- Provide filesystem async APIs with promises.
+- Provide `net`, `tls`, `http`, `https`, `crypto`, `zlib` equivalents.
+- Provide `path`, `os`, `process` equivalents with consistent naming.
+- Provide robust JSON, URL, and Buffer APIs.
+- Provide structured errors for stdlib failures.
+
+## Phase 5 — Security Hardening
+- Add a permission model for filesystem, network, and process execution.
+- Sandbox `Sistema.esegui` or remove by default.
+- Remove string‑built shell calls in stdlib.
+- Add input validation utilities and safe SQL helpers.
+- Add secure defaults for HTTP client and server.
+- Add dependency signature verification in VladPM.
+- Add audit tooling for known vulnerabilities.
+
+## Phase 6 — Performance & Memory
+- Add a bytecode compiler or IR to avoid deep AST walking.
+- Add a proper GC strategy or integrate with a VM that provides one.
+- Add incremental GC hooks for async workloads.
+- Add profiling tools (CPU, memory, async task tracking).
+- Add performance benchmarks for core runtime and stdlib.
+- Add a caching strategy for parsed modules.
+- Add fast path for numeric operations and tight loops.
+
+## Phase 7 — Language Features for Parity
+- Add default parameters, rest/spread, and destructuring improvements.
+- Add `try/catch` with error types and stack traces.
+- Add `finally` reliability guarantees with async.
+- Add `switch` strict matching options.
+- Add generators or iterators if in scope.
+- Add `for..of` and iterable protocol.
+- Add optional chaining and nullish coalescing everywhere.
+- Add proper `this` and `super` behavior in classes.
+- Add class fields and private fields if desired.
+
+## Phase 8 — Tooling (Developer Experience)
+- Add a debugger protocol and CLI debugger.
+- Add source maps for accurate error locations.
+- Add a test runner with snapshot support.
+- Add formatter and linter with Italian syntax rules.
+- Add language server (LSP) with autocomplete, go‑to‑definition, hover.
+- Add REPL improvements: history, auto‑completion, top‑level await.
+
+## Phase 9 — VladPM (Ecosystem)
+- Add semantic version resolution.
+- Add dependency tree lock correctness and integrity checks.
+- Add package cache and offline install.
+- Add `vladpm audit`.
+- Add `vladpm doctor`.
+- Add scoped packages and registry auth improvements.
+- Add registry replication and fallback mirrors.
+
+## Phase 10 — Docs and Community
+- Full reference documentation for language and stdlib.
+- Cookbook of patterns and migration guides.
+- Examples for web servers, CLIs, data processing, and automation.
+- Contribution guidelines, RFC process, and release process.
+
+## Phase 11 — Compatibility Goals
+- Define what “Node.js‑level” means in measurable terms.
+- Publish performance targets vs Node for key workloads.
+- Publish supported core APIs and their compatibility level.
+- Add a compatibility test suite.
+
+## Immediate Technical TODOs (from current codebase)
+- Fix `Archivio.*` path resolution relative to script directory.
+- Replace blocking `aspetta` busy‑wait with async sleep.
+- Replace `Rete.chiama` and `ClientWeb` curl usage with native HTTP.
+- Fix REPL `evaluate` call to pass the correct environment.
+- Improve error messages to include token context in parser errors.
+- Ensure `optional chaining` tokens parse correctly in member access and calls.
+- Add module path normalization and caching for absolute paths.
+
+## Risks to Track
+- Node parity is a multi‑year effort without a VM or JIT.
+- Security and dependency integrity become critical as adoption grows.
+- Backward compatibility can slow progress without clear versioning.
+
+## Suggested Execution Order
+1. Baseline Hygiene
+2. Correctness Fixes
+3. Real Async Runtime
+4. Module System Parity
+5. Stdlib Modernization
+6. Security Hardening
+7. Performance & Memory
+8. Tooling
+9. VladPM Ecosystem
+10. Docs and Community
+11. Compatibility Targets

package/programs/main/index.vx

@@ -1,15 +1,27 @@
-variabile passport = {}
-passport.nome = chiedi("Come ti chiami? ")
-se(Archivio.esiste(`passports/${passport.nome}.json`))  {
-    stampa("GIA ESISTE, VATTENE!!")
+importa {log, errore} da "@std/Console";
+classe Persona {
+    funzione costruttore(nome, eta) {
+        questo.nome = nome
+        questo.eta = eta
+    }
+    funzione eMaggiorenne() {
+        se(questo.eta >= 18) {
+            ritorna vero
+        } altrimenti {
+            ritorna falso
+        }
+    }
+}
+variabile nome = chiedi("Come ti chiami? ")
+se(Archivio.esiste(`passports/${nome}.json`))  {
+    errore("GIA ESISTE, VATTENE!!")
 } altrimenti {
-    passport.eta = chiedi("Quanti anni hai? ")
-
-    se(passport.eta >= 18) {
-        stampa("Sei maggiorenne")
+    variabile eta = chiedi("Quanti anni hai? ")
+    variabile persona = nuovo Persona(nome, eta)
+    se(persona.eMaggiorenne()) {
+        log("Sei maggiorenne")
     } altrimenti {
-        stampa("Sei minorenne")
+        log("Sei minorenne")
     }
-
-    Archivio.scrivi(`passports/${passport.nome}.json`, JSON.stringify(passport))
+    Archivio.scrivi(`passports/${nome}.json`, JSON.stringify(persona))
 }

package/programs/main/passports/Bobik.json

@@ -0,0 +1 @@
+{"klass":{"name":"Persona","superclass":null,"constructor":{"type":"FunctionDeclaration","name":"costruttore","params":["nome","eta"],"body":{"type":"BlockStatement","body":[{"type":"ExpressionStatement","expression":{"type":"AssignmentExpression","operator":"=","left":{"type":"MemberExpression","object":{"type":"ThisExpression"},"property":{"type":"Identifier","name":"nome"},"computed":false,"optional":false},"right":{"type":"Identifier","name":"nome"}}},{"type":"ExpressionStatement","expression":{"type":"AssignmentExpression","operator":"=","left":{"type":"MemberExpression","object":{"type":"ThisExpression"},"property":{"type":"Identifier","name":"eta"},"computed":false,"optional":false},"right":{"type":"Identifier","name":"eta"}}}]},"isAsync":false},"methods":{}},"fields":{}}

package/programs/tests/test_global_import.vx

@@ -0,0 +1,2 @@
+importa { saluta } da "testG";
+saluta();

package/scripts/install-setup.js

@@ -0,0 +1,36 @@
+/**
+ * VladX - Install Setup Script
+ * Crea le directory ~/.vladx e sottocartelle per vladpm.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const VLADX_HOME = path.join(os.homedir(), '.vladx');
+const VLADPM_HOME = path.join(VLADX_HOME, 'vladpm');
+const VLADPM_BIN = path.join(VLADPM_HOME, 'bin');
+
+console.log("📁 Preparazione ambiente VladX...");
+
+try {
+    if (!fs.existsSync(VLADX_HOME)) {
+        fs.mkdirSync(VLADX_HOME, { recursive: true });
+        console.log(`  ✓ Creata directory: ${VLADX_HOME}`);
+    }
+
+    if (!fs.existsSync(VLADPM_HOME)) {
+        fs.mkdirSync(VLADPM_HOME, { recursive: true });
+        console.log(`  ✓ Creata directory: ${VLADPM_HOME}`);
+    }
+
+    if (!fs.existsSync(VLADPM_BIN)) {
+        fs.mkdirSync(VLADPM_BIN, { recursive: true });
+        console.log(`  ✓ Creata directory: ${VLADPM_BIN}`);
+    }
+
+    console.log("✅ Ambiente configurato correttamente.");
+} catch (error) {
+    console.error(`✗ Errore durante la creazione delle directory: ${error.message}`);
+    process.exit(1);
+}