vladx 1.0.1

package/src/parser/parser.js

@@ -0,0 +1,476 @@
+/**
+ * VladX Parser
+ * Parser ricorsivo discendente per generare AST
+ */
+
+const { TokenType } = require('../lexer/tokens.js');
+const AST = require('./ast.js');
+
+class ParserError extends Error {
+    constructor(message, token) {
+        super(`Errore alla riga ${token.line}, colonna ${token.column}: ${message}`);
+        this.token = token;
+    }
+}
+
+class Parser {
+    constructor(tokens) {
+        this.tokens = tokens;
+        this.current = 0;
+    }
+
+    // === Utility Methods ===
+    peek() {
+        return this.tokens[this.current];
+    }
+
+    previous() {
+        return this.tokens[this.current - 1];
+    }
+
+    isAtEnd() {
+        return this.peek().type === TokenType.FINE;
+    }
+
+    advance() {
+        if (!this.isAtEnd()) this.current++;
+        return this.previous();
+    }
+
+    check(type) {
+        if (this.isAtEnd()) return false;
+        return this.peek().type === type;
+    }
+
+    match(...types) {
+        for (const type of types) {
+            if (this.check(type)) {
+                this.advance();
+                return true;
+            }
+        }
+        return false;
+    }
+
+    consume(type, message) {
+        if (this.check(type)) return this.advance();
+        throw new ParserError(message, this.peek());
+    }
+
+    // === Parsing Methods ===
+    parse() {
+        const statements = [];
+        while (!this.isAtEnd()) {
+            const stmt = this.declaration();
+            if (stmt) statements.push(stmt);
+        }
+        return new AST.Program(statements);
+    }
+
+    declaration() {
+        try {
+            if (this.match(TokenType.VARIABILE)) return this.variableDeclaration(false);
+            if (this.match(TokenType.COSTANTE)) return this.variableDeclaration(true);
+            if (this.match(TokenType.FUNZIONE)) return this.functionDeclaration();
+            return this.statement();
+        } catch (error) {
+            this.synchronize();
+            throw error;
+        }
+    }
+
+    variableDeclaration(isConstant) {
+        const name = this.consume(TokenType.IDENTIFICATORE, 'Nome variabile atteso').value;
+        let value = null;
+        if (this.match(TokenType.ASSEGNA)) {
+            value = this.expression();
+        }
+        this.match(TokenType.PUNTO_VIRGOLA);
+        return new AST.VariableDeclaration(name, value, isConstant);
+    }
+
+    functionDeclaration() {
+        const name = this.consume(TokenType.IDENTIFICATORE, 'Nome funzione atteso').value;
+        this.consume(TokenType.PARENTESI_APERTA, 'Atteso "(" dopo nome funzione');
+        const params = [];
+        if (!this.check(TokenType.PARENTESI_CHIUSA)) {
+            do {
+                params.push(this.consume(TokenType.IDENTIFICATORE, 'Nome parametro atteso').value);
+            } while (this.match(TokenType.VIRGOLA));
+        }
+        this.consume(TokenType.PARENTESI_CHIUSA, 'Atteso ")" dopo parametri');
+        this.consume(TokenType.GRAFFA_APERTA, 'Atteso "{" prima del corpo funzione');
+        const body = this.blockStatement();
+        return new AST.FunctionDeclaration(name, params, body);
+    }
+
+    statement() {
+        if (this.match(TokenType.SE)) return this.ifStatement();
+        if (this.match(TokenType.MENTRE)) return this.whileStatement();
+        if (this.match(TokenType.PER)) return this.forStatement();
+        if (this.match(TokenType.RITORNA)) return this.returnStatement();
+        if (this.match(TokenType.INTERROMPI)) return this.breakStatement();
+        if (this.match(TokenType.CONTINUA)) return this.continueStatement();
+        if (this.match(TokenType.STAMPA)) return this.printStatement();
+        if (this.match(TokenType.GRAFFA_APERTA)) return this.blockStatement();
+        return this.expressionStatement();
+    }
+
+    blockStatement() {
+        const statements = [];
+        while (!this.check(TokenType.GRAFFA_CHIUSA) && !this.isAtEnd()) {
+            statements.push(this.declaration());
+        }
+        this.consume(TokenType.GRAFFA_CHIUSA, 'Atteso "}" alla fine del blocco');
+        return new AST.BlockStatement(statements);
+    }
+
+    ifStatement() {
+        this.consume(TokenType.PARENTESI_APERTA, 'Atteso "(" dopo "se"');
+        const condition = this.expression();
+        this.consume(TokenType.PARENTESI_CHIUSA, 'Atteso ")" dopo condizione');
+        this.consume(TokenType.GRAFFA_APERTA, 'Atteso "{" dopo condizione');
+        const consequent = this.blockStatement();
+        let alternate = null;
+        if (this.match(TokenType.ALTRIMENTI)) {
+            if (this.match(TokenType.SE)) {
+                alternate = this.ifStatement();
+            } else {
+                this.consume(TokenType.GRAFFA_APERTA, 'Atteso "{" dopo "altrimenti"');
+                alternate = this.blockStatement();
+            }
+        }
+        return new AST.IfStatement(condition, consequent, alternate);
+    }
+
+    whileStatement() {
+        this.consume(TokenType.PARENTESI_APERTA, 'Atteso "(" dopo "mentre"');
+        const condition = this.expression();
+        this.consume(TokenType.PARENTESI_CHIUSA, 'Atteso ")" dopo condizione');
+        this.consume(TokenType.GRAFFA_APERTA, 'Atteso "{" dopo condizione');
+        const body = this.blockStatement();
+        return new AST.WhileStatement(condition, body);
+    }
+
+    forStatement() {
+        this.consume(TokenType.PARENTESI_APERTA, 'Atteso "(" dopo "per"');
+
+        let init = null;
+        if (this.match(TokenType.VARIABILE)) {
+            init = this.variableDeclaration(false);
+        } else if (!this.check(TokenType.PUNTO_VIRGOLA)) {
+            init = this.expressionStatement();
+        } else {
+            this.advance();
+        }
+
+        let condition = null;
+        if (!this.check(TokenType.PUNTO_VIRGOLA)) {
+            condition = this.expression();
+        }
+        this.consume(TokenType.PUNTO_VIRGOLA, 'Atteso ";" dopo condizione del ciclo');
+
+        let update = null;
+        if (!this.check(TokenType.PARENTESI_CHIUSA)) {
+            update = this.expression();
+        }
+        this.consume(TokenType.PARENTESI_CHIUSA, 'Atteso ")" dopo clausole del ciclo');
+
+        this.consume(TokenType.GRAFFA_APERTA, 'Atteso "{" dopo clausole del ciclo');
+        const body = this.blockStatement();
+        return new AST.ForStatement(init, condition, update, body);
+    }
+
+    returnStatement() {
+        let argument = null;
+        if (!this.check(TokenType.PUNTO_VIRGOLA) && !this.check(TokenType.GRAFFA_CHIUSA)) {
+            argument = this.expression();
+        }
+        this.match(TokenType.PUNTO_VIRGOLA);
+        return new AST.ReturnStatement(argument);
+    }
+
+    breakStatement() {
+        this.match(TokenType.PUNTO_VIRGOLA);
+        return new AST.BreakStatement();
+    }
+
+    continueStatement() {
+        this.match(TokenType.PUNTO_VIRGOLA);
+        return new AST.ContinueStatement();
+    }
+
+    printStatement() {
+        this.consume(TokenType.PARENTESI_APERTA, 'Atteso "(" dopo "stampa"');
+        const argument = this.expression();
+        this.consume(TokenType.PARENTESI_CHIUSA, 'Atteso ")" dopo argomento');
+        this.match(TokenType.PUNTO_VIRGOLA);
+        return new AST.PrintStatement(argument);
+    }
+
+    expressionStatement() {
+        const expr = this.expression();
+        this.match(TokenType.PUNTO_VIRGOLA);
+        return new AST.ExpressionStatement(expr);
+    }
+
+    // === Expression Parsing (Precedence Climbing) ===
+    expression() {
+        return this.assignment();
+    }
+
+    assignment() {
+        const expr = this.logicalOr();
+
+        if (this.match(TokenType.ASSEGNA, TokenType.PIU_ASSEGNA, TokenType.MENO_ASSEGNA)) {
+            const operator = this.previous().value;
+            const value = this.assignment();
+            return new AST.AssignmentExpression(operator, expr, value);
+        }
+
+        return expr;
+    }
+
+    logicalOr() {
+        let expr = this.logicalAnd();
+
+        while (this.match(TokenType.O, TokenType.OR)) {
+            const operator = '||';
+            const right = this.logicalAnd();
+            expr = new AST.LogicalExpression(operator, expr, right);
+        }
+
+        return expr;
+    }
+
+    logicalAnd() {
+        let expr = this.equality();
+
+        while (this.match(TokenType.E, TokenType.AND)) {
+            const operator = '&&';
+            const right = this.equality();
+            expr = new AST.LogicalExpression(operator, expr, right);
+        }
+
+        return expr;
+    }
+
+    equality() {
+        let expr = this.comparison();
+
+        while (this.match(TokenType.UGUALE, TokenType.DIVERSO, TokenType.UGUALE_STRETTO, TokenType.DIVERSO_STRETTO)) {
+            const operator = this.previous().value;
+            const right = this.comparison();
+            expr = new AST.BinaryExpression(operator, expr, right);
+        }
+
+        return expr;
+    }
+
+    comparison() {
+        let expr = this.term();
+
+        while (this.match(TokenType.MINORE, TokenType.MAGGIORE, TokenType.MINORE_UGUALE, TokenType.MAGGIORE_UGUALE)) {
+            const operator = this.previous().value;
+            const right = this.term();
+            expr = new AST.BinaryExpression(operator, expr, right);
+        }
+
+        return expr;
+    }
+
+    term() {
+        let expr = this.factor();
+
+        while (this.match(TokenType.PIU, TokenType.MENO)) {
+            const operator = this.previous().value;
+            const right = this.factor();
+            expr = new AST.BinaryExpression(operator, expr, right);
+        }
+
+        return expr;
+    }
+
+    factor() {
+        let expr = this.unary();
+
+        while (this.match(TokenType.MOLTIPLICA, TokenType.DIVIDI, TokenType.MODULO)) {
+            const operator = this.previous().value;
+            const right = this.unary();
+            expr = new AST.BinaryExpression(operator, expr, right);
+        }
+
+        return expr;
+    }
+
+    unary() {
+        if (this.match(TokenType.NON, TokenType.MENO)) {
+            const operator = this.previous().value === 'non' ? '!' : this.previous().value;
+            const argument = this.unary();
+            return new AST.UnaryExpression(operator, argument);
+        }
+
+        return this.postfix();
+    }
+
+    postfix() {
+        let expr = this.call();
+
+        while (this.match(TokenType.INCREMENTA, TokenType.DECREMENTA)) {
+            const operator = this.previous().value;
+            expr = new AST.UpdateExpression(operator, expr, false);
+        }
+
+        return expr;
+    }
+
+    call() {
+        let expr = this.primary();
+
+        while (true) {
+            if (this.match(TokenType.PARENTESI_APERTA)) {
+                expr = this.finishCall(expr);
+            } else if (this.match(TokenType.PUNTO)) {
+                const property = this.consume(TokenType.IDENTIFICATORE, 'Nome proprietà atteso dopo "."');
+                expr = new AST.MemberExpression(expr, new AST.Identifier(property.value), false);
+            } else if (this.match(TokenType.QUADRA_APERTA)) {
+                const property = this.expression();
+                this.consume(TokenType.QUADRA_CHIUSA, 'Atteso "]" dopo indice');
+                expr = new AST.MemberExpression(expr, property, true);
+            } else {
+                break;
+            }
+        }
+
+        return expr;
+    }
+
+    finishCall(callee) {
+        const args = [];
+        if (!this.check(TokenType.PARENTESI_CHIUSA)) {
+            do {
+                args.push(this.expression());
+            } while (this.match(TokenType.VIRGOLA));
+        }
+        this.consume(TokenType.PARENTESI_CHIUSA, 'Atteso ")" dopo argomenti');
+        return new AST.CallExpression(callee, args);
+    }
+
+    primary() {
+        if (this.match(TokenType.VERO)) return new AST.BooleanLiteral(true);
+        if (this.match(TokenType.FALSO)) return new AST.BooleanLiteral(false);
+        if (this.match(TokenType.NULLO)) return new AST.NullLiteral();
+
+        if (this.match(TokenType.NUMERO)) {
+            return new AST.NumericLiteral(this.previous().value);
+        }
+
+        if (this.match(TokenType.STRINGA)) {
+            return new AST.StringLiteral(this.previous().value);
+        }
+
+        if (this.match(TokenType.IDENTIFICATORE)) {
+            return new AST.Identifier(this.previous().value);
+        }
+
+        if (this.match(TokenType.QUESTO)) {
+            return new AST.Identifier('questo');
+        }
+
+        if (this.match(TokenType.QUADRA_APERTA)) {
+            return this.arrayLiteral();
+        }
+
+        if (this.match(TokenType.GRAFFA_APERTA)) {
+            return this.objectLiteral();
+        }
+
+        if (this.match(TokenType.PARENTESI_APERTA)) {
+            // Potrebbe essere una arrow function o un'espressione raggruppata
+            const startPos = this.current - 1;
+
+            // Prova a parsare come arrow function
+            if (this.check(TokenType.PARENTESI_CHIUSA) || this.check(TokenType.IDENTIFICATORE)) {
+                const params = [];
+                if (!this.check(TokenType.PARENTESI_CHIUSA)) {
+                    do {
+                        if (this.match(TokenType.IDENTIFICATORE)) {
+                            params.push(this.previous().value);
+                        } else {
+                            // Non è una arrow function, torna indietro
+                            this.current = startPos + 1;
+                            const expr = this.expression();
+                            this.consume(TokenType.PARENTESI_CHIUSA, 'Atteso ")" dopo espressione');
+                            return expr;
+                        }
+                    } while (this.match(TokenType.VIRGOLA));
+                }
+
+                if (this.match(TokenType.PARENTESI_CHIUSA) && this.match(TokenType.FRECCIA)) {
+                    // È una arrow function
+                    if (this.match(TokenType.GRAFFA_APERTA)) {
+                        const body = this.blockStatement();
+                        return new AST.ArrowFunction(params, body);
+                    } else {
+                        const body = this.expression();
+                        return new AST.ArrowFunction(params, body);
+                    }
+                } else {
+                    // Non è una arrow function, torna indietro
+                    this.current = startPos + 1;
+                }
+            }
+
+            const expr = this.expression();
+            this.consume(TokenType.PARENTESI_CHIUSA, 'Atteso ")" dopo espressione');
+            return expr;
+        }
+
+        throw new ParserError(`Token inaspettato: ${this.peek().type}`, this.peek());
+    }
+
+    arrayLiteral() {
+        const elements = [];
+        if (!this.check(TokenType.QUADRA_CHIUSA)) {
+            do {
+                elements.push(this.expression());
+            } while (this.match(TokenType.VIRGOLA));
+        }
+        this.consume(TokenType.QUADRA_CHIUSA, 'Atteso "]" alla fine dell\'array');
+        return new AST.ArrayLiteral(elements);
+    }
+
+    objectLiteral() {
+        const properties = [];
+        if (!this.check(TokenType.GRAFFA_CHIUSA)) {
+            do {
+                const key = this.consume(TokenType.IDENTIFICATORE, 'Nome proprietà atteso').value;
+                this.consume(TokenType.DUE_PUNTI, 'Atteso ":" dopo nome proprietà');
+                const value = this.expression();
+                properties.push(new AST.Property(key, value));
+            } while (this.match(TokenType.VIRGOLA));
+        }
+        this.consume(TokenType.GRAFFA_CHIUSA, 'Atteso "}" alla fine dell\'oggetto');
+        return new AST.ObjectLiteral(properties);
+    }
+
+    synchronize() {
+        this.advance();
+        while (!this.isAtEnd()) {
+            if (this.previous().type === TokenType.PUNTO_VIRGOLA) return;
+            switch (this.peek().type) {
+                case TokenType.FUNZIONE:
+                case TokenType.VARIABILE:
+                case TokenType.COSTANTE:
+                case TokenType.PER:
+                case TokenType.SE:
+                case TokenType.MENTRE:
+                case TokenType.RITORNA:
+                    return;
+            }
+            this.advance();
+        }
+    }
+}
+
+module.exports = { Parser, ParserError };

package/src/pm/cli.js

@@ -0,0 +1,130 @@
+/**
+ * VladPM CLI
+ * Package Manager per VladX
+ */
+
+const init = require('./commands/init.js');
+const login = require('./commands/login.js');
+const publish = require('./commands/publish.js');
+const install = require('./commands/install.js');
+const uninstall = require('./commands/uninstall.js');
+const search = require('./commands/search.js');
+const list = require('./commands/list.js');
+const config = require('./commands/config.js');
+
+const VERSION = '1.0.0';
+
+const COLORS = {
+    reset: '\x1b[0m',
+    bright: '\x1b[1m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    cyan: '\x1b[36m'
+};
+
+function colorize(text, color) {
+    return `${COLORS[color]}${text}${COLORS.reset}`;
+}
+
+function showHelp() {
+    console.log(`
+${colorize('VladPM', 'bright')} - Package Manager per VladX
+
+${colorize('Uso:', 'cyan')}
+  vladpm init                Inizializza un nuovo progetto
+  vladpm login               Login al registry
+  vladpm logout              Logout dal registry
+  vladpm publish             Pubblica il pacchetto
+  vladpm install [pkg]       Installa un pacchetto (o tutti da vladx.json)
+  vladpm uninstall <pkg>     Rimuove un pacchetto
+  vladpm search <query>      Cerca pacchetti
+  vladpm list                Lista pacchetti installati
+  vladpm --help, -h          Mostra questo aiuto
+  vladpm --version, -v       Mostra la versione
+
+${colorize('Esempi:', 'cyan')}
+  vladpm init
+  vladpm install mio-pacchetto
+  vladpm publish
+`);
+}
+
+function showVersion() {
+    console.log(`VladPM v${VERSION}`);
+}
+
+async function run(args) {
+    if (args.length === 0) {
+        showHelp();
+        return;
+    }
+
+    const command = args[0];
+
+    try {
+        switch (command) {
+            case '--help':
+            case '-h':
+            case 'help':
+                showHelp();
+                break;
+
+            case '--version':
+            case '-v':
+            case 'version':
+                showVersion();
+                break;
+
+            case 'init':
+                await init.execute(args.slice(1));
+                break;
+
+            case 'login':
+                await login.execute(args.slice(1));
+                break;
+
+            case 'logout':
+                await login.logout();
+                break;
+
+            case 'publish':
+                await publish.execute(args.slice(1));
+                break;
+
+            case 'install':
+            case 'i':
+                await install.execute(args.slice(1));
+                break;
+
+            case 'uninstall':
+            case 'remove':
+            case 'rm':
+                await uninstall.execute(args.slice(1));
+                break;
+
+            case 'search':
+                await search.execute(args.slice(1));
+                break;
+
+            case 'list':
+            case 'ls':
+                await list.execute(args.slice(1));
+                break;
+
+            case 'config':
+                await config.execute(args.slice(1));
+                break;
+
+            default:
+                console.error(colorize(`✗ Comando sconosciuto: ${command}`, 'red'));
+                console.log('Usa "vladpm --help" per vedere i comandi disponibili.');
+                process.exit(1);
+        }
+    } catch (error) {
+        console.error(colorize(`✗ Errore: ${error.message}`, 'red'));
+        process.exit(1);
+    }
+}
+
+module.exports = { run };

package/src/pm/commands/config.js

@@ -0,0 +1,76 @@
+/**
+ * VladPM - config command
+ */
+
+const { getConfig, saveConfig, getRegistry } = require('../utils/config.js');
+
+const COLORS = {
+    reset: '\x1b[0m',
+    bright: '\x1b[1m',
+    green: '\x1b[32m',
+    cyan: '\x1b[36m',
+    yellow: '\x1b[33m'
+};
+
+function colorize(text, color) {
+    return `${COLORS[color]}${text}${COLORS.reset}`;
+}
+
+async function execute(args) {
+    if (args.length === 0) {
+        // Show current config
+        console.log(colorize('\n⚙️  Configurazione VladPM\n', 'bright'));
+        const config = getConfig();
+        console.log(`  Registry: ${colorize(config.registry || 'default', 'cyan')}`);
+        if (config.username) {
+            console.log(`  Utente:   ${colorize(config.username, 'cyan')}`);
+        }
+        console.log();
+        return;
+    }
+
+    const subcommand = args[0];
+
+    if (subcommand === 'set') {
+        const key = args[1];
+        const value = args[2];
+
+        if (!key || !value) {
+            console.log(colorize('Uso: vladpm config set <chiave> <valore>', 'yellow'));
+            console.log('\nChiavi disponibili:');
+            console.log('  registry   URL del registry (es: http://localhost:3000)');
+            return;
+        }
+
+        const config = getConfig();
+
+        if (key === 'registry') {
+            config.registry = value;
+            saveConfig(config);
+            console.log(colorize(`✓ Registry impostato a: ${value}`, 'green'));
+        } else {
+            console.log(colorize(`✗ Chiave sconosciuta: ${key}`, 'yellow'));
+        }
+    } else if (subcommand === 'get') {
+        const key = args[1];
+        const config = getConfig();
+
+        if (key === 'registry') {
+            console.log(getRegistry());
+        } else if (key) {
+            console.log(config[key] || '');
+        } else {
+            console.log(JSON.stringify(config, null, 2));
+        }
+    } else if (subcommand === 'reset') {
+        const config = getConfig();
+        delete config.registry;
+        saveConfig(config);
+        console.log(colorize('✓ Configurazione resettata ai valori di default', 'green'));
+    } else {
+        console.log(colorize(`Sottocomando sconosciuto: ${subcommand}`, 'yellow'));
+        console.log('Usa: vladpm config [set|get|reset]');
+    }
+}
+
+module.exports = { execute };