error-ux-cli 1.0.0

package/lib/commands.js

@@ -0,0 +1,928 @@
+const fs = require('fs/promises');
+const auth = require('./auth');
+const git = require('./git');
+const news = require('./news');
+const storage = require('./storage');
+const utils = require('./utils');
+
+function askQuestion(rl, query) {
+    return new Promise((resolve) => rl.question(query, resolve));
+}
+
+async function selectOption(rl, options) {
+    options.forEach((option, index) => console.log(`${index + 1}. ${option}`));
+    const choice = await askQuestion(rl, 'Select an option (number): ');
+    const index = Number.parseInt(choice, 10) - 1;
+    return index >= 0 && index < options.length ? index : -1;
+}
+
+function getUserShortcuts(user) {
+    return user && user.shortcuts && typeof user.shortcuts === 'object' ? user.shortcuts : {};
+}
+
+function getUserTodos(user) {
+    return Array.isArray(user?.todo) ? user.todo : [];
+}
+
+function getUserRepos(user) {
+    return Array.isArray(user?.savedRepos) ? user.savedRepos : [];
+}
+
+function normalizeImportData(data) {
+    return {
+        name: typeof data?.name === 'string' && data.name.trim() ? data.name.trim() : 'Imported',
+        todos: Array.isArray(data?.todos) ? data.todos : [],
+        links: data?.links && typeof data.links === 'object' ? data.links : {},
+        repos: Array.isArray(data?.repos) ? data.repos : [],
+        newsApiKey: typeof data?.news_api_key === 'string' ? data.news_api_key : null
+    };
+}
+
+function normalizePathInput(value) {
+    const text = String(value || '').trim();
+    if (
+        (text.startsWith('"') && text.endsWith('"')) ||
+        (text.startsWith("'") && text.endsWith("'"))
+    ) {
+        return text.slice(1, -1).trim();
+    }
+    return text;
+}
+
+function normalizeDueBucket(value) {
+    const text = String(value || '').toLowerCase().trim();
+    if (text === 'tomorrow') return 'tmrw';
+    if (text === 'upcoming') return 'week';
+    if (text === 'month') return 'monthly';
+    if (text === 'year') return 'yearly';
+    if (['today', 'tmrw', 'week', 'monthly', 'yearly'].includes(text)) {
+        return text;
+    }
+    return 'today';
+}
+
+async function configureRemoteForPush(rl, targetRepo) {
+    const currentRemote = await git.getRemoteUrl();
+
+    if (!currentRemote) {
+        console.log('No remote origin found.');
+        const providedUrl = normalizePathInput(await askQuestion(rl, `Enter repository URL for ${targetRepo.name || 'origin'}: `));
+        if (!providedUrl || !utils.isValidUrl(providedUrl)) {
+            console.error('Error: Valid repository URL is required.');
+            return null;
+        }
+
+        targetRepo.url = providedUrl;
+        await git.setRemoteUrl(providedUrl, false);
+        return targetRepo;
+    }
+
+    console.log(`Current remote: ${currentRemote}`);
+
+    if (targetRepo.url && targetRepo.url !== currentRemote) {
+        const useSaved = await askQuestion(rl, 'Use the saved repository URL instead? (y/n): ');
+        if (useSaved.toLowerCase() === 'y') {
+            await git.setRemoteUrl(targetRepo.url, true);
+            return targetRepo;
+        }
+    }
+
+    const replace = await askQuestion(rl, 'Do you want to change the remote? (y/n): ');
+    if (replace.toLowerCase() !== 'y') {
+        return {
+            ...targetRepo,
+            url: currentRemote
+        };
+    }
+
+    const newUrl = normalizePathInput(await askQuestion(rl, 'Enter new repository URL: '));
+    if (!newUrl || !utils.isValidUrl(newUrl)) {
+        console.error('Error: Valid repository URL is required.');
+        return null;
+    }
+
+    await git.setRemoteUrl(newUrl, true);
+    return {
+        ...targetRepo,
+        url: newUrl
+    };
+}
+
+async function promptForRemoteReplacement(rl, targetRepo) {
+    const newUrl = normalizePathInput(await askQuestion(rl, 'Enter new repository URL: '));
+    if (!newUrl || !utils.isValidUrl(newUrl)) {
+        console.error('Error: Valid repository URL is required.');
+        return null;
+    }
+
+    await git.setRemoteUrl(newUrl, true);
+    return {
+        ...targetRepo,
+        url: newUrl
+    };
+}
+
+async function ensureUserNewsApiKey(rl, config, user, options = {}) {
+    const forcePrompt = Boolean(options.forcePrompt);
+    const currentKey = String(user.news_api_key || process.env.NEWS_API_KEY || '').trim();
+
+    if (!forcePrompt && currentKey) {
+        return currentKey;
+    }
+
+    const prompt = currentKey
+        ? 'News API Key (press Enter to keep current): '
+        : 'News API Key (press Enter to skip): ';
+    const entered = normalizePathInput(await askQuestion(rl, prompt)).trim();
+    const finalKey = entered || currentKey;
+
+    if (!finalKey) {
+        return null;
+    }
+
+    user.news_api_key = finalKey;
+    await storage.saveConfig(config);
+    utils.saveEnvValue('NEWS_API_KEY', finalKey);
+    return finalKey;
+}
+
+async function resolvePushBranch(rl, requestedBranch) {
+    const normalized = String(requestedBranch || '').trim();
+    if (!normalized) {
+        return null;
+    }
+
+    const exists = await git.branchExists(normalized);
+    if (!exists) {
+        console.log(`Branch not found. Creating new branch: ${normalized}`);
+        return normalized;
+    }
+
+    const nextVersion = await git.getNextBranchVersion(normalized);
+    const versionedBranch = `${normalized}_v${nextVersion}`;
+    console.log(`Branch "${normalized}" already exists.`);
+    const choice = await selectOption(rl, [
+        `Use existing branch: ${normalized}`,
+        `Create new branch: ${versionedBranch}`,
+        'Cancel'
+    ]);
+
+    if (choice === 0) {
+        return normalized;
+    }
+    if (choice === 1) {
+        return versionedBranch;
+    }
+    return null;
+}
+
+async function handleLink(rl) {
+    const config = await storage.loadConfig();
+    const user = storage.getActiveUser(config);
+    if (!user) return;
+
+    let url = await askQuestion(rl, 'Enter URL: ');
+    url = url.trim();
+    if (!url || !utils.isValidUrl(url)) {
+        console.error('Error: Invalid URL format.');
+        return;
+    }
+
+    let shortcut = await askQuestion(rl, 'Enter shortcut name: ');
+    shortcut = shortcut.toLowerCase().trim();
+
+    if (!shortcut || shortcut.includes(' ') || utils.isValidUrl(shortcut)) {
+        console.error('Error: Invalid shortcut name.');
+        return;
+    }
+
+    const shortcuts = getUserShortcuts(user);
+    if (shortcuts[shortcut]) {
+        const overwrite = await askQuestion(rl, `Shortcut "${shortcut}" already exists. Overwrite? (y/n): `);
+        if (overwrite.toLowerCase() !== 'y') {
+            console.log('Action cancelled.');
+            return;
+        }
+    }
+
+    shortcuts[shortcut] = {type: 'link', value: url};
+    user.shortcuts = shortcuts;
+
+    await storage.saveConfig(config);
+    console.log(`Shortcut "${shortcut}" saved successfully!`);
+}
+
+async function handleLinks() {
+    const config = await storage.loadConfig();
+    const user = storage.getActiveUser(config);
+    if (!user) return;
+
+    const shortcuts = getUserShortcuts(user);
+    const keys = Object.keys(shortcuts);
+    if (keys.length === 0) {
+        console.log('No shortcuts saved yet.');
+        return;
+    }
+
+    console.log('');
+    keys.sort().forEach((key) => {
+        console.log(`${key} -> ${shortcuts[key].value}`);
+    });
+    console.log('');
+}
+
+async function handleUnlink(rl, shortcut) {
+    let target = shortcut;
+    if (!target) {
+        target = await askQuestion(rl, 'Enter shortcut to delete: ');
+    }
+
+    const cleanShortcut = String(target || '').toLowerCase().trim();
+    const config = await storage.loadConfig();
+    const user = storage.getActiveUser(config);
+    if (!user) return;
+
+    const shortcuts = getUserShortcuts(user);
+    if (!shortcuts[cleanShortcut]) {
+        console.error(`Error: Shortcut "${cleanShortcut}" does not exist.`);
+        return;
+    }
+
+    delete shortcuts[cleanShortcut];
+    user.shortcuts = shortcuts;
+
+    await storage.saveConfig(config);
+    console.log(`Shortcut "${cleanShortcut}" deleted.`);
+}
+
+async function initOnboarding(rl) {
+    console.log('\n--- First-Time Onboarding ---');
+    console.log("Welcome to error-ux! Let's set up your profile.\n");
+
+    let name = '';
+    while (!name) {
+        name = (await askQuestion(rl, 'Choose a username: ')).trim();
+        if (!name) console.error('Error: Username is required.');
+    }
+
+    let password = '';
+    while (!password) {
+        password = await auth.askPassword(rl, 'Set a password (min 1 char): ');
+        if (!password) console.error('Error: Password must be at least 1 character.');
+    }
+
+    console.log('\n(Optional) News API key from GNews. Skip by pressing Enter.');
+    const newsApiKey = (await askQuestion(rl, 'News API Key: ')).trim();
+
+    const config = {
+        activeUser: name,
+        users: {
+            [name]: {
+                password_hash: auth.hashPassword(password),
+                news_api_key: newsApiKey || null,
+                shortcuts: {},
+                activeRepo: null,
+                savedRepos: [],
+                todo: []
+            }
+        }
+    };
+
+    if (newsApiKey) {
+        utils.saveEnvValue('NEWS_API_KEY', newsApiKey);
+    }
+
+    await storage.saveConfig(config);
+    console.log(`\nSetup complete. Welcome aboard, ${name}.\n`);
+    return config;
+}
+
+async function handleUser(rl, args) {
+    const config = (await storage.loadConfig()) || {activeUser: null, users: {}};
+    if (!config.users || typeof config.users !== 'object') {
+        config.users = {};
+    }
+
+    const parts = args ? args.trim().split(/\s+/) : [];
+    const command = parts[0]?.toLowerCase();
+
+    switch (command) {
+        case 'create': {
+            const inputName = parts[1] || await askQuestion(rl, 'Enter new username: ');
+            const newName = String(inputName || '').trim();
+            if (!newName) {
+                console.error('error');
+                return;
+            }
+            if (config.users[newName]) {
+                console.error('error');
+                return;
+            }
+
+            const newPwd = await auth.askPassword(rl, `Enter password for ${newName}: `);
+            if (!newPwd) {
+                console.error('error');
+                return;
+            }
+
+            config.users[newName] = {
+                password_hash: auth.hashPassword(newPwd),
+                news_api_key: null,
+                shortcuts: {},
+                activeRepo: null,
+                savedRepos: [],
+                todo: []
+            };
+            if (!config.activeUser) {
+                config.activeUser = newName;
+            }
+
+            await storage.saveConfig(config);
+            console.log(`User "${newName}" created.`);
+            return;
+        }
+
+        case 'login': {
+            const inputName = parts[1] || await askQuestion(rl, 'Username: ');
+            const loginName = String(inputName || '').trim();
+            if (!config.users[loginName]) {
+                console.error('error');
+                return;
+            }
+
+            const loginPwd = await auth.askPassword(rl, 'Password: ');
+            if (!auth.verifyPassword(loginPwd, config.users[loginName].password_hash)) {
+                console.error('error');
+                return;
+            }
+
+            config.activeUser = loginName;
+            await ensureUserNewsApiKey(rl, config, config.users[loginName], {forcePrompt: true});
+            await storage.saveConfig(config);
+            console.log(`Logged in as ${loginName}.`);
+            await handleDashboard(rl);
+            return;
+        }
+
+        case 'list':
+            console.log('\nProfiles:');
+            Object.keys(config.users).sort().forEach((username) => {
+                const active = config.activeUser === username ? '*' : ' ';
+                console.log(`${active} ${username}`);
+            });
+            return;
+
+        case 'current':
+            console.log(`Active user: ${config.activeUser || '(none)'}`);
+            return;
+
+        case 'delete': {
+            const inputName = parts[1] || await askQuestion(rl, 'Username to delete: ');
+            const deleteName = String(inputName || '').trim();
+            if (!config.users[deleteName]) {
+                console.error('error');
+                return;
+            }
+            if (deleteName === config.activeUser) {
+                console.error('error');
+                return;
+            }
+
+            delete config.users[deleteName];
+            await storage.saveConfig(config);
+            console.log(`User "${deleteName}" deleted.`);
+            return;
+        }
+
+        default:
+            console.log('Usage: user [create|login|list|current|delete]');
+    }
+}
+
+async function handleExport(rl, args) {
+    const config = await storage.loadConfig();
+    const user = storage.getActiveUser(config);
+    if (!user || !config?.activeUser) return;
+
+    const outputPath = normalizePathInput(args) || `error-ux-${config.activeUser}-data.json`;
+    const exportData = {
+        version: 1,
+        exported_at: new Date().toISOString(),
+        name: config.activeUser,
+        todos: getUserTodos(user),
+        links: getUserShortcuts(user),
+        repos: getUserRepos(user),
+        news_api_key: user.news_api_key || null
+    };
+
+    await fs.writeFile(outputPath, JSON.stringify(exportData, null, 2), 'utf8');
+    console.log(`Data exported to ${outputPath} (passwords excluded)`);
+}
+
+async function handleImport(rl, args) {
+    const filePath = normalizePathInput(args) || normalizePathInput(await askQuestion(rl, 'Enter path to import file: '));
+    if (!filePath) return;
+
+    try {
+        const raw = await fs.readFile(filePath.trim(), 'utf8');
+        const imported = normalizeImportData(JSON.parse(raw));
+        const config = (await storage.loadConfig()) || {activeUser: null, users: {}};
+        if (!config.users || typeof config.users !== 'object') {
+            config.users = {};
+        }
+
+        if (!config.users[imported.name]) {
+            console.log(`Creating new profile for "${imported.name}"...`);
+            const pwd = await auth.askPassword(rl, `Set initial password for ${imported.name}: `);
+            if (!pwd) {
+                console.error('error');
+                return;
+            }
+
+            config.users[imported.name] = {
+                password_hash: auth.hashPassword(pwd),
+                news_api_key: imported.newsApiKey,
+                shortcuts: imported.links,
+                activeRepo: imported.repos[0] || null,
+                savedRepos: imported.repos,
+                todo: imported.todos
+            };
+
+            if (!config.activeUser) {
+                config.activeUser = imported.name;
+            }
+        } else {
+            console.log(`Replacing data in existing profile "${imported.name}"...`);
+            const user = config.users[imported.name];
+            user.shortcuts = imported.links;
+            user.savedRepos = imported.repos;
+            user.activeRepo = imported.repos[0] || null;
+            user.todo = imported.todos;
+            user.news_api_key = imported.newsApiKey;
+        }
+
+        await storage.saveConfig(config);
+        console.log('Import successful.');
+    } catch {
+        console.error('error');
+    }
+}
+
+async function handleRepo(rl, args) {
+    const config = await storage.loadConfig();
+    const user = storage.getActiveUser(config);
+    if (!user) return;
+
+    user.savedRepos = getUserRepos(user);
+
+    const parts = args ? args.trim().split(/\s+/) : [];
+    const command = parts[0]?.toLowerCase();
+
+    switch (command) {
+        case 'set': {
+            const name = parts[1];
+            const url = parts[2];
+            if (!name || !url || !utils.isValidUrl(url)) {
+                console.error('Usage: repo set <name> <url>');
+                return;
+            }
+
+            const existingIndex = user.savedRepos.findIndex((repo) => repo.name === name);
+            if (existingIndex !== -1) {
+                user.savedRepos[existingIndex].url = url;
+            } else {
+                user.savedRepos.push({name, url});
+            }
+
+            await storage.saveConfig(config);
+            console.log(`Repository "${name}" saved.`);
+            return;
+        }
+
+        case 'use': {
+            const useName = parts[1];
+            const repo = user.savedRepos.find((item) => item.name === useName);
+            if (!repo) {
+                console.error('error');
+                return;
+            }
+
+            user.activeRepo = repo;
+            await storage.saveConfig(config);
+            console.log(`Now using repository: ${repo.name}`);
+            return;
+        }
+
+        case 'list':
+            if (user.savedRepos.length === 0) {
+                console.log('No saved repositories.');
+                return;
+            }
+
+            console.log('\nSaved Repositories:');
+            user.savedRepos.forEach((repo) => {
+                const active = user.activeRepo && user.activeRepo.name === repo.name ? '*' : ' ';
+                console.log(`${active} ${repo.name.padEnd(12)} -> ${repo.url}`);
+            });
+            return;
+
+        case 'current':
+            if (user.activeRepo) {
+                console.log(`Current active repository: ${user.activeRepo.name} (${user.activeRepo.url})`);
+            } else {
+                console.log('No active repository set.');
+            }
+            return;
+
+        default:
+            console.log('Usage: repo [set|use|list|current]');
+    }
+}
+
+async function handleUninstall(rl) {
+    const confirm = await askQuestion(rl, 'Are you sure you want to delete all error-ux data? (y/n): ');
+    if (confirm.toLowerCase() !== 'y') {
+        console.log('Uninstall cancelled.');
+        return;
+    }
+
+    const config = await storage.loadConfig();
+    const user = storage.getActiveUser(config);
+    if (!user) {
+        console.error('error');
+        return;
+    }
+
+    const authPassword = await auth.askPassword(rl, 'Confirm password to uninstall: ');
+    if (!auth.verifyPassword(authPassword, user.password_hash)) {
+        console.error('error');
+        return;
+    }
+
+    await storage.wipeAllData();
+    process.env.NEWS_API_KEY = '';
+    console.log('\nAll data deleted successfully.');
+    console.log('To complete the removal, run: npm uninstall -g error-ux');
+    process.exit(0);
+}
+
+async function handlePush(rl, args) {
+    if (!args) {
+        console.error('Error: Please provide a name for the push (e.g., push feature)');
+        return;
+    }
+
+    const config = await storage.loadConfig();
+    const user = storage.getActiveUser(config);
+    if (!user) return;
+
+    user.savedRepos = getUserRepos(user);
+
+    if (utils.isSystemFolder(process.cwd())) {
+        console.warn('\n--- WARNING ---');
+        console.warn('You are pushing from a system folder.');
+        const confirm = await askQuestion(rl, 'Proceed? (y/n): ');
+        if (confirm.toLowerCase() !== 'y') return;
+    }
+
+    const target = await git.getPushContext(args, user.savedRepos, rl);
+    if (!target || !target.targetRepo) return;
+
+    const resolvedBranch = await resolvePushBranch(rl, target.branchBase);
+    if (!resolvedBranch) {
+        console.log('Push cancelled.');
+        return;
+    }
+
+    const preparedRepo = await configureRemoteForPush(rl, {...target.targetRepo});
+    if (!preparedRepo) return;
+
+    try {
+        console.log(`Preparing push for branch: ${resolvedBranch}`);
+        const pushResult = await git.automatedPush(preparedRepo, target.message, resolvedBranch);
+        if (pushResult.branchExisted) {
+            console.log(`Using existing branch: ${pushResult.branch}`);
+        } else {
+            console.log(`Created branch: ${pushResult.branch}`);
+        }
+        if (pushResult.committed) {
+            console.log(`Committed changes: ${pushResult.message}`);
+        } else {
+            console.log('No new changes to commit. Pushing existing branch state.');
+        }
+        console.log(`Push successful: ${pushResult.branch} -> ${pushResult.remoteUrl}`);
+        if (!user.savedRepos.find((repo) => repo.url === preparedRepo.url)) {
+            user.savedRepos.push(preparedRepo);
+            await storage.saveConfig(config);
+        }
+    } catch (error) {
+        const detail = error?.stderr || error?.stdout || error?.message || '';
+        if (String(detail).includes('Repository not found')) {
+            console.error('Push failed: remote repository not found.');
+            const retry = await askQuestion(rl, 'Do you want to update the remote and retry? (y/n): ');
+            if (retry.toLowerCase() === 'y') {
+                const retriedRepo = await promptForRemoteReplacement(rl, preparedRepo);
+                if (!retriedRepo) return;
+
+                try {
+                    console.log(`Retrying push for branch: ${resolvedBranch}`);
+                    const retryResult = await git.automatedPush(retriedRepo, target.message, resolvedBranch);
+                    if (retryResult.branchExisted) {
+                        console.log(`Using existing branch: ${retryResult.branch}`);
+                    } else {
+                        console.log(`Created branch: ${retryResult.branch}`);
+                    }
+                    if (retryResult.committed) {
+                        console.log(`Committed changes: ${retryResult.message}`);
+                    } else {
+                        console.log('No new changes to commit. Pushing existing branch state.');
+                    }
+                    console.log(`Push successful: ${retryResult.branch} -> ${retryResult.remoteUrl}`);
+                    if (!user.savedRepos.find((repo) => repo.url === retriedRepo.url)) {
+                        user.savedRepos.push(retriedRepo);
+                        await storage.saveConfig(config);
+                    }
+                    return;
+                } catch (retryError) {
+                    const retryDetail = retryError?.stderr || retryError?.stdout || retryError?.message || '';
+                    const retryLine = String(retryDetail).trim().split(/\r?\n/).find(Boolean);
+                    console.error(retryLine ? `Push failed: ${retryLine}` : 'error');
+                    return;
+                }
+            }
+            return;
+        }
+
+        const line = String(detail).trim().split(/\r?\n/).find(Boolean);
+        console.error(line ? `Push failed: ${line}` : 'error');
+    }
+}
+
+async function handleDashboard(rl) {
+    const config = await storage.loadConfig();
+    const user = storage.getActiveUser(config);
+    if (!user) return;
+
+    const apiKey = user.news_api_key || process.env.NEWS_API_KEY;
+
+    const todoLines = getUserTodos(user).slice(0, 4).map((todo) => {
+        const icon = todo.status === 'completed' ? '[x]' : '[ ]';
+        return `${icon} ${todo.text}`;
+    });
+    if (todoLines.length === 0) todoLines.push('(No active tasks)');
+
+    const shortcutLines = Object.entries(getUserShortcuts(user)).slice(0, 4).map(([key, value]) => {
+        const rawValue = typeof value === 'string' ? value : value?.value;
+        const label = rawValue ? rawValue.replace(/^https?:\/\//, '').slice(0, 14) : '';
+        return label ? `${key} -> ${label}` : key;
+    });
+    if (shortcutLines.length === 0) shortcutLines.push('(No shortcuts)');
+
+    let newsLines = [];
+    if (apiKey) {
+        try {
+            const result = await news.fetchArticles(null, 2, apiKey);
+            if (result.articles && result.articles.length > 0) {
+                newsLines = result.articles.slice(0, 2).map((article) => `* ${article.title}`);
+            } else {
+                newsLines = ['* No recent news available'];
+            }
+        } catch {
+            newsLines = ['* No recent news available'];
+        }
+    } else {
+        newsLines = ['* No API key (onboarding optional)'];
+    }
+
+    const now = new Date();
+    const dateStr = now.toLocaleDateString('en-US', {month: 'short', day: '2-digit'}).toUpperCase();
+    const timeStr = now.toLocaleTimeString('en-US', {hour: '2-digit', minute: '2-digit', hour12: true});
+    const {renderDashboard} = await import('./dashboard.mjs');
+
+    await renderDashboard({
+        menu: 'LINK | PUSH | TODO | NEWS | HELP',
+        dateTime: `${dateStr}  ${timeStr}`,
+        todoLines,
+        shortcutLines,
+        newsLines
+    });
+
+    console.log('');
+}
+
+async function handleNews(rl, args) {
+    const config = await storage.loadConfig();
+    const user = storage.getActiveUser(config);
+    if (!user) return;
+
+    const apiKey = user.news_api_key || process.env.NEWS_API_KEY;
+    if (!apiKey) {
+        console.log('No API key found. Opening Google News...');
+        utils.openBrowser('https://news.google.com');
+        return;
+    }
+
+    let query = '';
+    let limit = 5;
+    if (args) {
+        const parts = args.trim().split(/\s+/);
+        if (parts.length > 1 && !Number.isNaN(Number.parseInt(parts[parts.length - 1], 10))) {
+            limit = Number.parseInt(parts.pop(), 10);
+            query = parts.join(' ');
+        } else if (parts.length === 1 && !Number.isNaN(Number.parseInt(parts[0], 10))) {
+            limit = Number.parseInt(parts[0], 10);
+        } else {
+            query = args.trim();
+        }
+    }
+
+    console.log('\nFetching latest news...');
+    try {
+        const result = await news.fetchArticles(query, limit, apiKey);
+        if (!result.articles || result.articles.length === 0) {
+            console.log('No news found.');
+            return;
+        }
+
+        console.log('\nNews:\n');
+        result.articles.forEach((article, index) => {
+            console.log(`${index + 1}. ${article.title}`);
+            console.log(`   Source: ${article.source.name}\n`);
+        });
+
+        const choice = await askQuestion(rl, 'Enter number once you open article or Enter to exit: ');
+        const index = Number.parseInt(choice, 10);
+        if (!Number.isNaN(index) && index > 0 && index <= result.articles.length) {
+            utils.openBrowser(result.articles[index - 1].url);
+        }
+    } catch {
+        console.error('error');
+    }
+}
+
+async function handleTodo(rl, args) {
+    const config = await storage.loadConfig();
+    const user = storage.getActiveUser(config);
+    if (!user) return;
+
+    user.todo = getUserTodos(user).map((task) => ({
+        ...task,
+        due: normalizeDueBucket(task.due)
+    }));
+
+    const renderHeader = (text) => console.log(`\n${text}:`);
+    const renderTasks = (tasks) => {
+        if (tasks.length === 0) {
+            console.log('   (No tasks)');
+            return;
+        }
+
+        const sorted = [...tasks].sort((left, right) => {
+            if (left.status === right.status) return 0;
+            return left.status === 'pending' ? -1 : 1;
+        });
+
+        sorted.forEach((task) => {
+            const icon = task.status === 'completed' ? '[x]' : '[ ]';
+            console.log(`  ${icon} ${task.id}. ${task.text}`);
+        });
+    };
+
+    if (!args || args.trim() === '') {
+        console.log('\n--- Todo Management ---');
+        const options = ['Add', 'List', 'Done', 'Delete', 'Today', 'Tmrw', 'Week', 'Monthly', 'Yearly', 'Back'];
+        const choice = await selectOption(rl, options);
+        if (choice === -1 || choice === 9) return;
+
+        switch (choice) {
+            case 0: {
+                const text = await askQuestion(rl, 'Task: ');
+                if (!text) return;
+
+                const dueChoice = await selectOption(rl, ['Today', 'Tmrw', 'Week', 'Monthly', 'Yearly']);
+                const dueList = ['today', 'tmrw', 'week', 'monthly', 'yearly'];
+                const due = dueChoice !== -1 ? dueList[dueChoice] : 'today';
+                const maxId = user.todo.reduce((max, task) => Math.max(max, task.id || 0), 0);
+                user.todo.push({id: maxId + 1, text: text.trim(), status: 'pending', due});
+                await storage.saveConfig(config);
+                return;
+            }
+
+            case 1:
+                renderHeader('Today');
+                renderTasks(user.todo.filter((task) => task.due === 'today'));
+                renderHeader('Tmrw');
+                renderTasks(user.todo.filter((task) => task.due === 'tmrw'));
+                renderHeader('Week');
+                renderTasks(user.todo.filter((task) => task.due === 'week'));
+                renderHeader('Monthly');
+                renderTasks(user.todo.filter((task) => task.due === 'monthly'));
+                renderHeader('Yearly');
+                renderTasks(user.todo.filter((task) => task.due === 'yearly'));
+                return;
+
+            case 2: {
+                const doneId = Number.parseInt(await askQuestion(rl, 'ID: '), 10);
+                const task = user.todo.find((item) => item.id === doneId);
+                if (task) {
+                    task.status = 'completed';
+                    await storage.saveConfig(config);
+                }
+                return;
+            }
+
+            case 3: {
+                const deleteId = Number.parseInt(await askQuestion(rl, 'ID: '), 10);
+                const deleteIndex = user.todo.findIndex((item) => item.id === deleteId);
+                if (deleteIndex !== -1) {
+                    user.todo.splice(deleteIndex, 1);
+                    await storage.saveConfig(config);
+                }
+                return;
+            }
+
+            default:
+                return;
+        }
+    }
+
+    const parts = args.trim().split(/\s+/);
+    const command = parts[0]?.toLowerCase();
+    const rest = parts.slice(1).join(' ');
+
+    switch (command) {
+        case 'add': {
+            const maxId = user.todo.reduce((max, task) => Math.max(max, task.id || 0), 0);
+            user.todo.push({id: maxId + 1, text: rest || 'Task', status: 'pending', due: 'today'});
+            await storage.saveConfig(config);
+            return;
+        }
+
+        case 'done': {
+            const task = user.todo.find((item) => item.id === Number.parseInt(rest, 10));
+            if (task) {
+                task.status = 'completed';
+                await storage.saveConfig(config);
+            }
+            return;
+        }
+
+        case 'list':
+        default:
+            renderTasks(user.todo);
+    }
+}
+
+async function handleMenu() {
+    console.log('\nAvailable Commands:');
+    console.log('user        -> Manage profiles (create|login|list|current|delete)');
+    console.log('export      -> Backup your active profile');
+    console.log('import      -> Restore or merge profile data');
+    console.log('repo        -> Manage repositories (set|use|list|current)');
+    console.log('link        -> Add a new shortcut');
+    console.log('links       -> View all shortcuts');
+    console.log('unlink      -> Delete a shortcut');
+    console.log('push        -> Automated Git push');
+    console.log('news        -> Fetch latest news');
+    console.log('todo        -> Manage tasks');
+    console.log('help        -> Show this menu');
+    console.log('uninstall   -> Wipe all error-ux data');
+    console.log('exit        -> Exit CLI');
+    console.log('<shortcut>  -> Open a saved link\n');
+}
+
+async function handleShortcut(shortcut) {
+    const cleanShortcut = String(shortcut || '').toLowerCase().trim();
+    const config = await storage.loadConfig();
+    const user = storage.getActiveUser(config);
+    if (!user) return false;
+
+    const shortcuts = getUserShortcuts(user);
+    const target = shortcuts[cleanShortcut];
+    if (!target) return false;
+
+    const url = typeof target === 'string' ? target : target.value;
+    console.log(`Opening ${url}...`);
+    utils.openBrowser(url);
+    return true;
+}
+
+module.exports = {
+    askQuestion,
+    ensureUserNewsApiKey,
+    handleDashboard,
+    handleExport,
+    handleImport,
+    handleLink,
+    handleLinks,
+    handleMenu,
+    handleNews,
+    handlePush,
+    handleRepo,
+    handleShortcut,
+    handleTodo,
+    handleUninstall,
+    handleUnlink,
+    handleUser,
+    initOnboarding
+};