vladx 1.0.1

package/src/pm/commands/uninstall.js

@@ -0,0 +1,68 @@
+/**
+ * VladPM - uninstall command
+ */
+
+const fs = require('fs');
+const path = require('path');
+const {
+    getVladxJson,
+    saveVladxJson,
+    getVladxLock,
+    saveVladxLock,
+    getModulesDir
+} = require('../utils/config.js');
+
+const COLORS = {
+    reset: '\x1b[0m',
+    bright: '\x1b[1m',
+    green: '\x1b[32m',
+    red: '\x1b[31m',
+    yellow: '\x1b[33m'
+};
+
+function colorize(text, color) {
+    return `${COLORS[color]}${text}${COLORS.reset}`;
+}
+
+async function execute(args) {
+    if (args.length === 0) {
+        console.log(colorize('✗ Specificare il nome del pacchetto da rimuovere.', 'red'));
+        console.log('Uso: vladpm uninstall <pacchetto>');
+        process.exit(1);
+    }
+
+    const packages = args.filter(a => !a.startsWith('-'));
+
+    console.log(colorize('\n🗑️  Rimozione pacchetti\n', 'bright'));
+
+    for (const name of packages) {
+        const modulesDir = getModulesDir();
+        const packageDir = path.join(modulesDir, name);
+
+        // Remove from filesystem
+        if (fs.existsSync(packageDir)) {
+            fs.rmSync(packageDir, { recursive: true });
+            console.log(colorize(`  ✓ Rimosso ${name}`, 'green'));
+        } else {
+            console.log(colorize(`  ⚠ ${name} non installato`, 'yellow'));
+        }
+
+        // Update vladx.json
+        const vladxJson = getVladxJson();
+        if (vladxJson && vladxJson.dependencies && vladxJson.dependencies[name]) {
+            delete vladxJson.dependencies[name];
+            saveVladxJson(vladxJson);
+        }
+
+        // Update lock file
+        const lock = getVladxLock();
+        if (lock.dependencies && lock.dependencies[name]) {
+            delete lock.dependencies[name];
+            saveVladxLock(lock);
+        }
+    }
+
+    console.log();
+}
+
+module.exports = { execute };

package/src/pm/utils/api.js

@@ -0,0 +1,135 @@
+/**
+ * VladPM API Client
+ */
+
+const http = require('http');
+const https = require('https');
+const { URL } = require('url');
+const { getRegistry, getToken } = require('./config.js');
+
+function request(method, endpoint, data = null, options = {}) {
+    return new Promise((resolve, reject) => {
+        const registry = options.registry || getRegistry();
+        const url = new URL(endpoint, registry);
+        const isHttps = url.protocol === 'https:';
+        const client = isHttps ? https : http;
+
+        const reqOptions = {
+            hostname: url.hostname,
+            port: url.port || (isHttps ? 443 : 80),
+            path: url.pathname + url.search,
+            method: method,
+            headers: {
+                'Content-Type': 'application/json',
+                'User-Agent': 'VladPM/1.0.0'
+            }
+        };
+
+        // Add auth token if available
+        const token = options.token || getToken();
+        if (token) {
+            reqOptions.headers['Authorization'] = `Bearer ${token}`;
+        }
+
+        // Add custom headers
+        if (options.headers) {
+            Object.assign(reqOptions.headers, options.headers);
+        }
+
+        const req = client.request(reqOptions, (res) => {
+            let body = '';
+            res.on('data', chunk => body += chunk);
+            res.on('end', () => {
+                try {
+                    const parsed = body ? JSON.parse(body) : {};
+                    if (res.statusCode >= 200 && res.statusCode < 300) {
+                        resolve({ status: res.statusCode, data: parsed });
+                    } else {
+                        reject(new Error(parsed.error || parsed.message || `HTTP ${res.statusCode}`));
+                    }
+                } catch (e) {
+                    if (res.statusCode >= 200 && res.statusCode < 300) {
+                        resolve({ status: res.statusCode, data: body });
+                    } else {
+                        reject(new Error(`HTTP ${res.statusCode}: ${body}`));
+                    }
+                }
+            });
+        });
+
+        req.on('error', (e) => {
+            if (e.code === 'ECONNREFUSED') {
+                reject(new Error('Impossibile connettersi al registry. Verifica che vladpm-server sia in esecuzione.'));
+            } else {
+                reject(e);
+            }
+        });
+
+        if (data) {
+            const payload = typeof data === 'string' ? data : JSON.stringify(data);
+            req.write(payload);
+        }
+
+        req.end();
+    });
+}
+
+async function get(endpoint, options = {}) {
+    return request('GET', endpoint, null, options);
+}
+
+async function post(endpoint, data, options = {}) {
+    return request('POST', endpoint, data, options);
+}
+
+async function put(endpoint, data, options = {}) {
+    return request('PUT', endpoint, data, options);
+}
+
+async function del(endpoint, options = {}) {
+    return request('DELETE', endpoint, null, options);
+}
+
+// Package-specific API calls
+async function login(username, password) {
+    return post('/auth/login', { username, password });
+}
+
+async function register(username, email, password) {
+    return post('/auth/register', { username, email, password });
+}
+
+async function getPackage(name) {
+    return get(`/packages/${encodeURIComponent(name)}`);
+}
+
+async function getPackageVersion(name, version) {
+    return get(`/packages/${encodeURIComponent(name)}/${encodeURIComponent(version)}`);
+}
+
+async function publishPackage(packageData) {
+    return put(`/packages/${encodeURIComponent(packageData.name)}`, packageData);
+}
+
+async function searchPackages(query) {
+    return get(`/search?q=${encodeURIComponent(query)}`);
+}
+
+async function unpublishPackage(name) {
+    return del(`/packages/${encodeURIComponent(name)}`);
+}
+
+module.exports = {
+    request,
+    get,
+    post,
+    put,
+    del,
+    login,
+    register,
+    getPackage,
+    getPackageVersion,
+    publishPackage,
+    searchPackages,
+    unpublishPackage
+};

package/src/pm/utils/config.js

@@ -0,0 +1,117 @@
+/**
+ * VladPM Config Utilities
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const CONFIG_DIR = path.join(os.homedir(), '.vladpm');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+const VLADX_JSON = 'vladx.json';
+const VLADX_LOCK = 'vladx-lock.json';
+const MODULES_DIR = 'vladx_modules';
+
+// Default registry URL
+const DEFAULT_REGISTRY = 'http://185.105.108.233:6789';
+
+function ensureConfigDir() {
+    if (!fs.existsSync(CONFIG_DIR)) {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+}
+
+function getConfig() {
+    ensureConfigDir();
+    if (fs.existsSync(CONFIG_FILE)) {
+        return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+    }
+    return { registry: DEFAULT_REGISTRY };
+}
+
+function saveConfig(config) {
+    ensureConfigDir();
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+
+function getToken() {
+    const config = getConfig();
+    return config.token || null;
+}
+
+function setToken(token, username) {
+    const config = getConfig();
+    config.token = token;
+    config.username = username;
+    saveConfig(config);
+}
+
+function clearToken() {
+    const config = getConfig();
+    delete config.token;
+    delete config.username;
+    saveConfig(config);
+}
+
+function getRegistry() {
+    const config = getConfig();
+    return config.registry || DEFAULT_REGISTRY;
+}
+
+function getVladxJson(dir = process.cwd()) {
+    const filePath = path.join(dir, VLADX_JSON);
+    if (fs.existsSync(filePath)) {
+        return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    }
+    return null;
+}
+
+function saveVladxJson(data, dir = process.cwd()) {
+    const filePath = path.join(dir, VLADX_JSON);
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + '\n');
+}
+
+function getVladxLock(dir = process.cwd()) {
+    const filePath = path.join(dir, VLADX_LOCK);
+    if (fs.existsSync(filePath)) {
+        return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    }
+    return { lockfileVersion: 1, dependencies: {} };
+}
+
+function saveVladxLock(data, dir = process.cwd()) {
+    const filePath = path.join(dir, VLADX_LOCK);
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + '\n');
+}
+
+function getModulesDir(dir = process.cwd()) {
+    return path.join(dir, MODULES_DIR);
+}
+
+function ensureModulesDir(dir = process.cwd()) {
+    const modulesDir = getModulesDir(dir);
+    if (!fs.existsSync(modulesDir)) {
+        fs.mkdirSync(modulesDir, { recursive: true });
+    }
+    return modulesDir;
+}
+
+module.exports = {
+    CONFIG_DIR,
+    VLADX_JSON,
+    VLADX_LOCK,
+    MODULES_DIR,
+    DEFAULT_REGISTRY,
+    getConfig,
+    saveConfig,
+    getToken,
+    setToken,
+    clearToken,
+    getRegistry,
+    getVladxJson,
+    saveVladxJson,
+    getVladxLock,
+    saveVladxLock,
+    getModulesDir,
+    ensureModulesDir
+};

package/src/repl/repl.js

@@ -0,0 +1,179 @@
+/**
+ * VladX REPL
+ * Read-Eval-Print Loop interattivo
+ */
+
+const readline = require('readline');
+const { Lexer } = require('../lexer/lexer.js');
+const { Parser } = require('../parser/parser.js');
+const { Interpreter } = require('../interpreter/interpreter.js');
+
+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 colorize(text, color) {
+    return `${COLORS[color]}${text}${COLORS.reset}`;
+}
+
+class REPL {
+    constructor() {
+        this.interpreter = new Interpreter();
+        this.history = [];
+        this.multilineBuffer = '';
+        this.openBraces = 0;
+    }
+
+    start() {
+        console.log(colorize('\n╔═══════════════════════════════════════════════════╗', 'cyan'));
+        console.log(colorize('║', 'cyan') + colorize('         🚀 VladX REPL v1.0.0                      ', 'bright') + colorize('║', 'cyan'));
+        console.log(colorize('║', 'cyan') + '   Linguaggio di programmazione con sintassi       ' + colorize('║', 'cyan'));
+        console.log(colorize('║', 'cyan') + '   italiana. Digita "aiuto" per la guida.          ' + colorize('║', 'cyan'));
+        console.log(colorize('╚═══════════════════════════════════════════════════╝\n', 'cyan'));
+
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            prompt: colorize('vladx> ', 'green'),
+            historySize: 100
+        });
+
+        rl.prompt();
+
+        rl.on('line', (line) => {
+            const trimmed = line.trim();
+
+            // Handle special commands
+            if (trimmed === 'esci' || trimmed === 'exit') {
+                console.log(colorize('\nArrivederci! 👋\n', 'cyan'));
+                process.exit(0);
+            }
+
+            if (trimmed === 'aiuto' || trimmed === 'help') {
+                this.showHelp();
+                rl.prompt();
+                return;
+            }
+
+            if (trimmed === 'pulisci' || trimmed === 'clear') {
+                console.clear();
+                rl.prompt();
+                return;
+            }
+
+            if (trimmed === '') {
+                rl.prompt();
+                return;
+            }
+
+            // Handle multiline input
+            this.multilineBuffer += line + '\n';
+            this.openBraces += (line.match(/{/g) || []).length;
+            this.openBraces -= (line.match(/}/g) || []).length;
+
+            if (this.openBraces > 0) {
+                rl.setPrompt(colorize('...   ', 'yellow'));
+                rl.prompt();
+                return;
+            }
+
+            // Execute the code
+            const code = this.multilineBuffer.trim();
+            this.multilineBuffer = '';
+            this.openBraces = 0;
+
+            if (code) {
+                this.history.push(code);
+                this.execute(code);
+            }
+
+            rl.setPrompt(colorize('vladx> ', 'green'));
+            rl.prompt();
+        });
+
+        rl.on('close', () => {
+            console.log(colorize('\nArrivederci! 👋\n', 'cyan'));
+            process.exit(0);
+        });
+    }
+
+    execute(code) {
+        try {
+            const lexer = new Lexer(code);
+            const tokens = lexer.tokenize();
+
+            const parser = new Parser(tokens);
+            const ast = parser.parse();
+
+            const result = this.interpreter.interpret(ast);
+
+            // Show result if it's not just print statements
+            if (result.length === 0 && ast.body.length > 0) {
+                const lastStmt = ast.body[ast.body.length - 1];
+                if (lastStmt.type === 'ExpressionStatement') {
+                    const lexer2 = new Lexer(code);
+                    const tokens2 = lexer2.tokenize();
+                    const parser2 = new Parser(tokens2);
+                    const ast2 = parser2.parse();
+
+                    // Create a fresh interpreter to get the expression value
+                    const tempInterpreter = new Interpreter();
+                    tempInterpreter.globals = this.interpreter.globals;
+                    tempInterpreter.environment = this.interpreter.environment;
+
+                    try {
+                        const value = tempInterpreter.evaluate(lastStmt.expression);
+                        if (value !== undefined && value !== null) {
+                            console.log(colorize('→ ', 'dim') + colorize(this.interpreter.stringify(value), 'yellow'));
+                        }
+                    } catch (e) {
+                        // Ignore
+                    }
+                }
+            }
+        } catch (error) {
+            console.log(colorize('✗ Errore: ', 'red') + error.message);
+        }
+    }
+
+    showHelp() {
+        console.log(colorize('\n📚 Guida VladX REPL\n', 'bright'));
+        console.log(colorize('Comandi REPL:', 'cyan'));
+        console.log('  aiuto, help     Mostra questa guida');
+        console.log('  pulisci, clear  Pulisce lo schermo');
+        console.log('  esci, exit      Esce dal REPL\n');
+
+        console.log(colorize('Sintassi VladX:', 'cyan'));
+        console.log('  variabile x = 10     Dichiarazione variabile');
+        console.log('  costante PI = 3.14   Dichiarazione costante');
+        console.log('  stampa("Ciao!")      Stampa output');
+        console.log('  se (cond) { }        Condizionale');
+        console.log('  mentre (cond) { }    Ciclo while');
+        console.log('  per (init;cond;upd)  Ciclo for');
+        console.log('  funzione f(x) { }    Dichiarazione funzione\n');
+
+        console.log(colorize('Operatori logici:', 'cyan'));
+        console.log('  e / &&      AND logico');
+        console.log('  o / ||      OR logico');
+        console.log('  non / !     NOT logico\n');
+
+        console.log(colorize('Valori:', 'cyan'));
+        console.log('  vero / falso    Boolean');
+        console.log('  nullo           Null\n');
+    }
+}
+
+function startREPL() {
+    const repl = new REPL();
+    repl.start();
+}
+
+module.exports = { REPL, startREPL };