vladx 1.0.1

package/src/pm/commands/init.js

@@ -0,0 +1,129 @@
+/**
+ * VladPM - init command
+ * Inizializza un nuovo progetto VladX
+ */
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+const { VLADX_JSON, saveVladxJson, saveVladxLock } = 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}`;
+}
+
+function prompt(question) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+
+    return new Promise(resolve => {
+        rl.question(question, answer => {
+            rl.close();
+            resolve(answer);
+        });
+    });
+}
+
+async function execute(args) {
+    const cwd = process.cwd();
+    const existingJson = path.join(cwd, VLADX_JSON);
+
+    if (fs.existsSync(existingJson) && !args.includes('-y') && !args.includes('--yes')) {
+        const overwrite = await prompt(colorize('vladx.json già esiste. Sovrascrivere? (s/N): ', 'yellow'));
+        if (overwrite.toLowerCase() !== 's' && overwrite.toLowerCase() !== 'si') {
+            console.log('Operazione annullata.');
+            return;
+        }
+    }
+
+    console.log(colorize('\n📦 Inizializzazione nuovo progetto VladX\n', 'bright'));
+
+    let packageData;
+
+    if (args.includes('-y') || args.includes('--yes')) {
+        // Default values
+        const dirName = path.basename(cwd);
+        packageData = {
+            name: dirName,
+            version: '1.0.0',
+            description: '',
+            main: 'index.vx',
+            scripts: {
+                start: 'vladx index.vx',
+                test: 'vladx test.vx'
+            },
+            keywords: [],
+            author: '',
+            license: 'MIT',
+            dependencies: {}
+        };
+    } else {
+        const dirName = path.basename(cwd);
+
+        const name = await prompt(`Nome pacchetto: (${dirName}) `) || dirName;
+        const version = await prompt('Versione: (1.0.0) ') || '1.0.0';
+        const description = await prompt('Descrizione: ') || '';
+        const main = await prompt('Entry point: (index.vx) ') || 'index.vx';
+        const author = await prompt('Autore: ') || '';
+        const license = await prompt('Licenza: (MIT) ') || 'MIT';
+        const keywordsStr = await prompt('Keywords (separate da virgola): ') || '';
+        const keywords = keywordsStr ? keywordsStr.split(',').map(k => k.trim()).filter(k => k) : [];
+
+        packageData = {
+            name,
+            version,
+            description,
+            main,
+            scripts: {
+                start: `vladx ${main}`,
+                test: 'vladx test.vx'
+            },
+            keywords,
+            author,
+            license,
+            dependencies: {}
+        };
+    }
+
+    // Save vladx.json
+    saveVladxJson(packageData);
+    console.log(colorize(`\n✓ Creato ${VLADX_JSON}`, 'green'));
+
+    // Create empty vladx-lock.json
+    saveVladxLock({
+        lockfileVersion: 1,
+        requires: true,
+        dependencies: {}
+    });
+    console.log(colorize('✓ Creato vladx-lock.json', 'green'));
+
+    // Create main file if it doesn't exist
+    const mainFile = path.join(cwd, packageData.main);
+    if (!fs.existsSync(mainFile)) {
+        fs.writeFileSync(mainFile, `// ${packageData.name} - Entry Point
+// Scrivi il tuo codice VladX qui
+
+stampa("Ciao da ${packageData.name}!");
+`);
+        console.log(colorize(`✓ Creato ${packageData.main}`, 'green'));
+    }
+
+    console.log(colorize('\n✨ Progetto inizializzato con successo!\n', 'cyan'));
+    console.log('Prossimi passi:');
+    console.log(`  1. Modifica ${colorize(packageData.main, 'bright')}`);
+    console.log(`  2. Esegui con ${colorize('vladx ' + packageData.main, 'bright')}`);
+    console.log(`  3. Pubblica con ${colorize('vladpm publish', 'bright')}`);
+    console.log();
+}
+
+module.exports = { execute };

package/src/pm/commands/install.js

@@ -0,0 +1,185 @@
+/**
+ * VladPM - install command
+ */
+
+const fs = require('fs');
+const path = require('path');
+const zlib = require('zlib');
+const api = require('../utils/api.js');
+const {
+    getVladxJson,
+    saveVladxJson,
+    getVladxLock,
+    saveVladxLock,
+    ensureModulesDir,
+    getModulesDir
+} = require('../utils/config.js');
+
+const COLORS = {
+    reset: '\x1b[0m',
+    bright: '\x1b[1m',
+    green: '\x1b[32m',
+    red: '\x1b[31m',
+    cyan: '\x1b[36m',
+    yellow: '\x1b[33m',
+    dim: '\x1b[2m'
+};
+
+function colorize(text, color) {
+    return `${COLORS[color]}${text}${COLORS.reset}`;
+}
+
+async function installPackage(name, version = 'latest', save = true) {
+    console.log(colorize(`  ⬇ ${name}${version !== 'latest' ? '@' + version : ''}`, 'dim'));
+
+    try {
+        // Fetch package info
+        const result = await api.getPackage(name);
+        const pkg = result.data;
+
+        if (!pkg) {
+            throw new Error(`Pacchetto "${name}" non trovato`);
+        }
+
+        // Get version to install
+        const versionToInstall = version === 'latest'
+            ? pkg.latestVersion || pkg.version
+            : version;
+
+        // Get package tarball
+        const versionData = await api.getPackageVersion(name, versionToInstall);
+
+        if (!versionData.data || !versionData.data.tarball) {
+            throw new Error(`Versione ${versionToInstall} non trovata per ${name}`);
+        }
+
+        // Decompress tarball
+        const compressed = Buffer.from(versionData.data.tarball, 'base64');
+        const decompressed = zlib.gunzipSync(compressed);
+        const packageContent = JSON.parse(decompressed.toString());
+
+        // Create package directory
+        const modulesDir = ensureModulesDir();
+        const packageDir = path.join(modulesDir, name);
+
+        if (fs.existsSync(packageDir)) {
+            fs.rmSync(packageDir, { recursive: true });
+        }
+        fs.mkdirSync(packageDir, { recursive: true });
+
+        // Extract files
+        for (const file of packageContent.files || []) {
+            const filePath = path.join(packageDir, file.path);
+            const dirPath = path.dirname(filePath);
+
+            if (!fs.existsSync(dirPath)) {
+                fs.mkdirSync(dirPath, { recursive: true });
+            }
+
+            fs.writeFileSync(filePath, file.content);
+        }
+
+        // Create package vladx.json in module folder
+        const moduleVladx = {
+            name: packageContent.name,
+            version: packageContent.version,
+            description: packageContent.description,
+            main: packageContent.main,
+            dependencies: packageContent.dependencies
+        };
+        fs.writeFileSync(
+            path.join(packageDir, 'vladx.json'),
+            JSON.stringify(moduleVladx, null, 2)
+        );
+
+        // Update vladx.json if --save
+        if (save) {
+            const vladxJson = getVladxJson() || { dependencies: {} };
+            if (!vladxJson.dependencies) vladxJson.dependencies = {};
+            vladxJson.dependencies[name] = `^${versionToInstall}`;
+            saveVladxJson(vladxJson);
+        }
+
+        // Update lock file
+        const lock = getVladxLock();
+        if (!lock.dependencies) lock.dependencies = {};
+        lock.dependencies[name] = {
+            version: versionToInstall,
+            resolved: `${name}@${versionToInstall}`,
+            integrity: Buffer.from(compressed).toString('base64').slice(0, 64)
+        };
+        saveVladxLock(lock);
+
+        console.log(colorize(`  ✓ ${name}@${versionToInstall}`, 'green'));
+
+        // Install dependencies
+        if (packageContent.dependencies) {
+            for (const [depName, depVersion] of Object.entries(packageContent.dependencies)) {
+                await installPackage(depName, depVersion.replace(/[\^~]/, ''), false);
+            }
+        }
+
+        return { name, version: versionToInstall };
+    } catch (error) {
+        console.log(colorize(`  ✗ ${name}: ${error.message}`, 'red'));
+        throw error;
+    }
+}
+
+async function execute(args) {
+    console.log(colorize('\n📦 Installazione pacchetti\n', 'bright'));
+
+    if (args.length === 0) {
+        // Install all from vladx.json
+        const vladxJson = getVladxJson();
+        if (!vladxJson) {
+            console.log(colorize('✗ vladx.json non trovato.', 'red'));
+            console.log(`Usa ${colorize('vladpm init', 'bright')} per inizializzare.`);
+            process.exit(1);
+        }
+
+        const deps = vladxJson.dependencies || {};
+        const depCount = Object.keys(deps).length;
+
+        if (depCount === 0) {
+            console.log('Nessuna dipendenza da installare.');
+            return;
+        }
+
+        console.log(`Installazione di ${depCount} dipendenze...\n`);
+
+        let installed = 0;
+        let failed = 0;
+
+        for (const [name, version] of Object.entries(deps)) {
+            try {
+                await installPackage(name, version.replace(/[\^~]/, ''), false);
+                installed++;
+            } catch (e) {
+                failed++;
+            }
+        }
+
+        console.log(`\n${colorize(`✓ ${installed} pacchetti installati`, 'green')}`);
+        if (failed > 0) {
+            console.log(colorize(`✗ ${failed} pacchetti falliti`, 'red'));
+        }
+    } else {
+        // Install specific packages
+        const saveDev = args.includes('--save-dev') || args.includes('-D');
+        const packages = args.filter(a => !a.startsWith('-'));
+
+        for (const pkg of packages) {
+            const [name, version] = pkg.split('@');
+            try {
+                await installPackage(name, version || 'latest', true);
+            } catch (e) {
+                // Error already logged
+            }
+        }
+    }
+
+    console.log();
+}
+
+module.exports = { execute, installPackage };

package/src/pm/commands/list.js

@@ -0,0 +1,70 @@
+/**
+ * VladPM - list command
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { getVladxJson, getModulesDir } = require('../utils/config.js');
+
+const COLORS = {
+    reset: '\x1b[0m',
+    bright: '\x1b[1m',
+    green: '\x1b[32m',
+    cyan: '\x1b[36m',
+    dim: '\x1b[2m',
+    yellow: '\x1b[33m'
+};
+
+function colorize(text, color) {
+    return `${COLORS[color]}${text}${COLORS.reset}`;
+}
+
+async function execute(args) {
+    const modulesDir = getModulesDir();
+    const vladxJson = getVladxJson();
+
+    console.log(colorize('\n📦 Pacchetti installati\n', 'bright'));
+
+    if (!fs.existsSync(modulesDir)) {
+        console.log(colorize('Nessun pacchetto installato.', 'dim'));
+        console.log(`Usa ${colorize('vladpm install <pacchetto>', 'bright')} per installare.\n`);
+        return;
+    }
+
+    const packages = fs.readdirSync(modulesDir, { withFileTypes: true })
+        .filter(d => d.isDirectory())
+        .map(d => d.name);
+
+    if (packages.length === 0) {
+        console.log(colorize('Nessun pacchetto installato.', 'dim'));
+        return;
+    }
+
+    const deps = vladxJson?.dependencies || {};
+
+    for (const name of packages) {
+        const pkgPath = path.join(modulesDir, name, 'vladx.json');
+        let version = '?';
+        let description = '';
+
+        if (fs.existsSync(pkgPath)) {
+            try {
+                const pkgJson = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+                version = pkgJson.version || '?';
+                description = pkgJson.description || '';
+            } catch (e) {
+                // Ignore
+            }
+        }
+
+        const inDeps = deps[name] ? colorize(' (dipendenza)', 'dim') : '';
+        console.log(`  ${colorize(name, 'cyan')}@${version}${inDeps}`);
+        if (description && args.includes('-l')) {
+            console.log(colorize(`    ${description}`, 'dim'));
+        }
+    }
+
+    console.log(colorize(`\nTotale: ${packages.length} pacchetti\n`, 'dim'));
+}
+
+module.exports = { execute };

package/src/pm/commands/login.js

@@ -0,0 +1,124 @@
+/**
+ * VladPM - login command
+ */
+
+const readline = require('readline');
+const api = require('../utils/api.js');
+const { setToken, clearToken, getConfig, getRegistry } = require('../utils/config.js');
+
+const COLORS = {
+    reset: '\x1b[0m',
+    bright: '\x1b[1m',
+    green: '\x1b[32m',
+    red: '\x1b[31m',
+    cyan: '\x1b[36m',
+    yellow: '\x1b[33m'
+};
+
+function colorize(text, color) {
+    return `${COLORS[color]}${text}${COLORS.reset}`;
+}
+
+function prompt(question, hidden = false) {
+    return new Promise(resolve => {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+
+        if (hidden) {
+            process.stdout.write(question);
+            const stdin = process.stdin;
+            stdin.setRawMode(true);
+            stdin.resume();
+            stdin.setEncoding('utf8');
+
+            let password = '';
+            const handler = (char) => {
+                if (char === '\n' || char === '\r' || char === '\u0004') {
+                    stdin.setRawMode(false);
+                    stdin.removeListener('data', handler);
+                    console.log();
+                    rl.close();
+                    resolve(password);
+                } else if (char === '\u0003') {
+                    process.exit();
+                } else if (char === '\u007F' || char === '\b') {
+                    if (password.length > 0) {
+                        password = password.slice(0, -1);
+                        process.stdout.write('\b \b');
+                    }
+                } else {
+                    password += char;
+                    process.stdout.write('*');
+                }
+            };
+            stdin.on('data', handler);
+        } else {
+            rl.question(question, answer => {
+                rl.close();
+                resolve(answer);
+            });
+        }
+    });
+}
+
+async function execute(args) {
+    console.log(colorize('\n🔐 Login a VladPM Registry\n', 'bright'));
+    console.log(`Registry: ${colorize(getRegistry(), 'cyan')}\n`);
+
+    const isRegister = args.includes('--register') || args.includes('-r');
+
+    if (isRegister) {
+        // Registration flow
+        const username = await prompt('Username: ');
+        const email = await prompt('Email: ');
+        const password = await prompt('Password: ', true);
+        const confirmPassword = await prompt('Conferma Password: ', true);
+
+        if (password !== confirmPassword) {
+            console.log(colorize('\n✗ Le password non corrispondono', 'red'));
+            process.exit(1);
+        }
+
+        try {
+            const result = await api.register(username, email, password);
+            console.log(colorize(`\n✓ Registrazione completata! Benvenuto ${username}`, 'green'));
+
+            // Auto-login after registration
+            const loginResult = await api.login(username, password);
+            setToken(loginResult.data.token, username);
+            console.log(colorize('✓ Login automatico eseguito', 'green'));
+        } catch (error) {
+            console.log(colorize(`\n✗ Registrazione fallita: ${error.message}`, 'red'));
+            process.exit(1);
+        }
+    } else {
+        // Login flow
+        const username = await prompt('Username: ');
+        const password = await prompt('Password: ', true);
+
+        try {
+            const result = await api.login(username, password);
+            setToken(result.data.token, username);
+            console.log(colorize(`\n✓ Login effettuato come ${username}`, 'green'));
+        } catch (error) {
+            console.log(colorize(`\n✗ Login fallito: ${error.message}`, 'red'));
+            console.log(`\nNon hai un account? Usa ${colorize('vladpm login --register', 'bright')}`);
+            process.exit(1);
+        }
+    }
+}
+
+async function logout() {
+    const config = getConfig();
+    if (config.token) {
+        const username = config.username || 'utente';
+        clearToken();
+        console.log(colorize(`✓ Logout effettuato (${username})`, 'green'));
+    } else {
+        console.log(colorize('Non sei loggato.', 'yellow'));
+    }
+}
+
+module.exports = { execute, logout };

package/src/pm/commands/publish.js

@@ -0,0 +1,115 @@
+/**
+ * VladPM - publish command
+ */
+
+const fs = require('fs');
+const path = require('path');
+const zlib = require('zlib');
+const api = require('../utils/api.js');
+const { getVladxJson, getToken } = require('../utils/config.js');
+
+const COLORS = {
+    reset: '\x1b[0m',
+    bright: '\x1b[1m',
+    green: '\x1b[32m',
+    red: '\x1b[31m',
+    cyan: '\x1b[36m',
+    yellow: '\x1b[33m'
+};
+
+function colorize(text, color) {
+    return `${COLORS[color]}${text}${COLORS.reset}`;
+}
+
+function getAllFiles(dir, baseDir = dir, files = []) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        const relativePath = path.relative(baseDir, fullPath);
+
+        // Skip node_modules, vladx_modules, and hidden files
+        if (entry.name.startsWith('.') ||
+            entry.name === 'node_modules' ||
+            entry.name === 'vladx_modules') {
+            continue;
+        }
+
+        if (entry.isDirectory()) {
+            getAllFiles(fullPath, baseDir, files);
+        } else {
+            files.push({
+                path: relativePath,
+                content: fs.readFileSync(fullPath, 'utf8')
+            });
+        }
+    }
+
+    return files;
+}
+
+async function execute(args) {
+    console.log(colorize('\n📦 Pubblicazione pacchetto\n', 'bright'));
+
+    // Check if logged in
+    const token = getToken();
+    if (!token) {
+        console.log(colorize('✗ Devi effettuare il login prima di pubblicare.', 'red'));
+        console.log(`Usa ${colorize('vladpm login', 'bright')} per accedere.`);
+        process.exit(1);
+    }
+
+    // Read vladx.json
+    const vladxJson = getVladxJson();
+    if (!vladxJson) {
+        console.log(colorize('✗ vladx.json non trovato.', 'red'));
+        console.log(`Usa ${colorize('vladpm init', 'bright')} per inizializzare il progetto.`);
+        process.exit(1);
+    }
+
+    console.log(`Nome: ${colorize(vladxJson.name, 'cyan')}`);
+    console.log(`Versione: ${colorize(vladxJson.version, 'cyan')}`);
+
+    // Collect all files
+    const files = getAllFiles(process.cwd());
+    console.log(`File: ${files.length}`);
+
+    // Create package data
+    const packageData = {
+        name: vladxJson.name,
+        version: vladxJson.version,
+        description: vladxJson.description || '',
+        main: vladxJson.main || 'index.vx',
+        keywords: vladxJson.keywords || [],
+        author: vladxJson.author || '',
+        license: vladxJson.license || 'MIT',
+        dependencies: vladxJson.dependencies || {},
+        files: files
+    };
+
+    // Compress
+    const compressed = zlib.gzipSync(JSON.stringify(packageData));
+    const base64Data = compressed.toString('base64');
+
+    try {
+        console.log('\nPubblicazione in corso...');
+        await api.publishPackage({
+            name: vladxJson.name,
+            version: vladxJson.version,
+            description: vladxJson.description,
+            main: vladxJson.main,
+            keywords: vladxJson.keywords,
+            author: vladxJson.author,
+            license: vladxJson.license,
+            dependencies: vladxJson.dependencies,
+            tarball: base64Data
+        });
+
+        console.log(colorize(`\n✓ Pubblicato ${vladxJson.name}@${vladxJson.version}`, 'green'));
+    } catch (error) {
+        console.log(colorize(`\n✗ Pubblicazione fallita: ${error.message}`, 'red'));
+        process.exit(1);
+    }
+}
+
+module.exports = { execute };

package/src/pm/commands/search.js

@@ -0,0 +1,55 @@
+/**
+ * VladPM - search command
+ */
+
+const api = require('../utils/api.js');
+
+const COLORS = {
+    reset: '\x1b[0m',
+    bright: '\x1b[1m',
+    green: '\x1b[32m',
+    red: '\x1b[31m',
+    cyan: '\x1b[36m',
+    dim: '\x1b[2m'
+};
+
+function colorize(text, color) {
+    return `${COLORS[color]}${text}${COLORS.reset}`;
+}
+
+async function execute(args) {
+    const query = args.filter(a => !a.startsWith('-')).join(' ');
+
+    if (!query) {
+        console.log(colorize('✗ Specificare una query di ricerca.', 'red'));
+        console.log('Uso: vladpm search <query>');
+        process.exit(1);
+    }
+
+    console.log(colorize(`\n🔍 Ricerca: "${query}"\n`, 'bright'));
+
+    try {
+        const result = await api.searchPackages(query);
+        const packages = result.data.packages || result.data || [];
+
+        if (packages.length === 0) {
+            console.log(colorize('Nessun pacchetto trovato.', 'dim'));
+            return;
+        }
+
+        console.log(`Trovati ${packages.length} pacchetti:\n`);
+
+        for (const pkg of packages) {
+            console.log(`${colorize(pkg.name, 'cyan')}@${pkg.version || pkg.latestVersion}`);
+            if (pkg.description) {
+                console.log(colorize(`  ${pkg.description}`, 'dim'));
+            }
+            console.log();
+        }
+    } catch (error) {
+        console.log(colorize(`✗ Ricerca fallita: ${error.message}`, 'red'));
+        process.exit(1);
+    }
+}
+
+module.exports = { execute };