error-ux-cli 1.0.0

package/lib/dashboard.mjs

@@ -0,0 +1,152 @@
+import React, {useEffect, useState} from 'react';
+import {Box, Text, render, useApp} from 'ink';
+
+const e = React.createElement;
+
+function fitText(value, width) {
+    const text = String(value ?? '');
+    if (text.length <= width) return text;
+    return text.slice(0, Math.max(0, width - 1)) + '\u2026';
+}
+
+function useTicker(intervalMs = 120) {
+    const [tick, setTick] = useState(0);
+
+    useEffect(() => {
+        const timer = setInterval(() => {
+            setTick(current => current + 1);
+        }, intervalMs);
+
+        return () => clearInterval(timer);
+    }, [intervalMs]);
+
+    return tick;
+}
+
+function AnimatedText({text, speed = 2}) {
+    const [tick, setTick] = useState(0);
+
+    useEffect(() => {
+        const timer = setInterval(() => {
+            setTick(current => Math.min(text.length, current + speed));
+        }, 35);
+
+        return () => clearInterval(timer);
+    }, [speed, text.length]);
+
+    return e(Text, null, text.slice(0, tick));
+}
+
+function RotatingCube() {
+    const tick = useTicker(140);
+    const frames = [
+        ['   +----+', '  /    /|', ' +----+ |', ' |    | +', ' |    |/', ' +----+'],
+        ['  .----.', ' /    /|', '.----. |', '|    | .', '|    |/', "'----'"],
+        ['  +----+', '  |\\    \\', '  | +----+', '  + |    |', '   \\|    |', '    +----+'],
+        [' .----.', ' |\\    \\', ' | .----.', ' . |    |', '  \\|    |', "   '----'"]
+    ];
+    const frame = frames[tick % frames.length];
+
+    return e(
+        Box,
+        {flexDirection: 'column', marginRight: 2},
+        ...frame.map((line, index) => e(Text, {key: `cube-${index}`, color: 'cyan'}, line))
+    );
+}
+
+function LoadingBar({width = 24}) {
+    const tick = useTicker(90);
+    const filled = tick % (width + 1);
+    const bar = '\u2588'.repeat(filled) + '\u2591'.repeat(width - filled);
+
+    return e(Text, {color: 'green'}, `[${bar}]`);
+}
+
+function LiveStatus() {
+    const tick = useTicker(180);
+    const statuses = [
+        'rotating cube',
+        'drawing dashboard',
+        'warming command deck',
+        'syncing panels'
+    ];
+
+    return e(Text, {color: 'yellow'}, statuses[tick % statuses.length]);
+}
+
+function IntroPanel({done}) {
+    return e(
+        Box,
+        {borderStyle: 'round', width: 68, paddingX: 1, marginBottom: 1},
+        e(RotatingCube),
+        e(
+            Box,
+            {flexDirection: 'column', justifyContent: 'center'},
+            done
+                ? e(Text, {bold: true, color: 'green'}, 'Welcome Aniruth')
+                : e(AnimatedText, {text: 'Welcome Aniruth', speed: 1}),
+            e(Text, {dimColor: true}, 'terminal cockpit online'),
+            e(LiveStatus),
+            e(LoadingBar, {width: 24})
+        )
+    );
+}
+
+function SectionTitle({children}) {
+    return e(Text, {bold: true, color: 'cyan'}, children);
+}
+
+function Dashboard({data}) {
+    const {exit} = useApp();
+    const [stage, setStage] = useState(0);
+    const maxRows = Math.max(data.todoLines.length, data.shortcutLines.length, 4);
+
+    useEffect(() => {
+        const timers = [
+            setTimeout(() => setStage(1), 1400),
+            setTimeout(() => setStage(2), 2400),
+            setTimeout(() => setStage(3), 3400),
+            setTimeout(() => exit(), 8000)
+        ];
+
+        return () => timers.forEach(clearTimeout);
+    }, [exit]);
+
+    return e(
+        Box,
+        {flexDirection: 'column'},
+        e(IntroPanel, {done: stage > 0}),
+        stage >= 1 && e(
+            Box,
+            {borderStyle: 'double', width: 68, marginBottom: 1},
+            e(Text, {color: 'yellow'}, `${data.menu}${' '.repeat(Math.max(0, 61 - data.menu.length - data.dateTime.length))}${data.dateTime}`)
+        ),
+        stage >= 2 && e(
+            Box,
+            {flexDirection: 'row', marginBottom: 1},
+            e(
+                Box,
+                {borderStyle: 'round', width: 38, flexDirection: 'column', marginRight: 2},
+                e(SectionTitle, null, 'ACTIVE TASKS (todo)'),
+                ...Array.from({length: maxRows}, (_, index) => e(Text, {key: `task-${index}`}, fitText(data.todoLines[index] || '', 32)))
+            ),
+            e(
+                Box,
+                {borderStyle: 'round', width: 28, flexDirection: 'column'},
+                e(SectionTitle, null, 'SHORTCUTS (links)'),
+                ...Array.from({length: maxRows}, (_, index) => e(Text, {key: `shortcut-${index}`}, fitText(data.shortcutLines[index] || '', 22)))
+            )
+        ),
+        stage >= 3 && e(
+            Box,
+            {borderStyle: 'round', width: 68, flexDirection: 'column'},
+            e(SectionTitle, null, 'LATEST NEWS (news)'),
+            ...data.newsLines.map((line, index) => e(Text, {key: `news-${index}`}, fitText(line, 62)))
+        )
+    );
+}
+
+export async function renderDashboard(data) {
+    const instance = render(e(Dashboard, {data}));
+    await instance.waitUntilExit();
+}

package/lib/git.js

@@ -0,0 +1,265 @@
+const { execSync } = require('child_process');
+const fs = require('fs/promises');
+const path = require('path');
+
+function runGit(command) {
+    try {
+        return execSync(command, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
+    } catch (error) {
+        throw error;
+    }
+}
+
+function quoteShellArg(value) {
+    return `"${String(value).replace(/"/g, '\\"')}"`;
+}
+
+function sanitizeBranchName(value) {
+    return String(value || 'update')
+        .trim()
+        .replace(/\s+/g, '-')
+        .replace(/[^A-Za-z0-9._/-]/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^[-/.]+|[-/.]+$/g, '') || 'update';
+}
+
+async function isGitRepo() {
+    try {
+        runGit('git rev-parse --is-inside-work-tree');
+        return true;
+    } catch (err) {
+        return false;
+    }
+}
+
+async function getRepoRoot() {
+    try {
+        const root = runGit('git rev-parse --show-toplevel');
+        return path.resolve(root);
+    } catch (err) {
+        return null;
+    }
+}
+
+async function getRemoteUrl() {
+    try {
+        return runGit('git remote get-url origin');
+    } catch (err) {
+        return null;
+    }
+}
+
+async function setRemoteUrl(url, exists) {
+    if (exists) {
+        runGit(`git remote set-url origin ${quoteShellArg(url)}`);
+    } else {
+        runGit(`git remote add origin ${quoteShellArg(url)}`);
+    }
+}
+
+async function initRepo() {
+    runGit('git init');
+}
+
+async function getNextBranchVersion(name) {
+    try {
+        // Try fetch but ignore errors (e.g. no internet, bad remote)
+        try {
+            runGit('git fetch --all');
+        } catch (e) {
+            // Silence fetch errors for versioning
+        }
+
+        const branches = runGit('git branch -a');
+        const regex = new RegExp(`${name}_v(\\d+)`, 'g');
+        let maxVersion = 0;
+        let match;
+        
+        while ((match = regex.exec(branches)) !== null) {
+            const version = parseInt(match[1]);
+            if (version > maxVersion) maxVersion = version;
+        }
+        
+        return maxVersion + 1;
+    } catch (error) {
+        // Fallback to v1 only if we can't even list branches
+        return 1;
+    }
+}
+
+async function branchExists(name) {
+    const branch = sanitizeBranchName(name);
+    try {
+        const output = runGit(`git branch -a --list ${quoteShellArg(branch)} ${quoteShellArg(`remotes/origin/${branch}`)}`);
+        return Boolean(String(output || '').trim());
+    } catch (error) {
+        return false;
+    }
+}
+
+async function updateREADME(version, message) {
+    const readmePath = path.join(process.cwd(), 'README.md');
+    let content = '';
+    
+    try {
+        content = await fs.readFile(readmePath, 'utf8');
+    } catch (error) {
+        if (error.code === 'ENOENT') {
+            content = '# Project\n\n## 🚀 Changelog\n';
+        } else {
+            throw error;
+        }
+    }
+
+    const changelogHeader = '## 🚀 Changelog';
+    const newEntry = `v${version} - ${message}`;
+    
+    if (content.includes(newEntry)) return; // Prevent duplicates
+
+    if (content.includes(changelogHeader)) {
+        const parts = content.split(changelogHeader);
+        content = parts[0] + changelogHeader + '\n\n' + newEntry + '\n' + parts[1].trim();
+    } else {
+        content = content.trim() + '\n\n' + changelogHeader + '\n\n' + newEntry + '\n';
+    }
+
+    await fs.writeFile(readmePath, content, 'utf8');
+}
+
+async function getDashboardStatus() {
+    try {
+        if (!(await isGitRepo())) return null;
+        const branch = runGit('git branch --show-current');
+        const status = runGit('git status --porcelain');
+        const changes = status ? status.split('\n').filter(l => l.trim()).length : 0;
+        return { branch, changes };
+    } catch (err) {
+        return null;
+    }
+}
+
+async function getPushContext(args, savedRepos, rl) {
+    const parts = String(args || '').trim().split(/\s+/).filter(Boolean);
+    if (parts.length === 0) {
+        return null;
+    }
+
+    let repoName = null;
+    let repoUrl = null;
+    const remaining = [];
+
+    for (let index = 0; index < parts.length; index++) {
+        const part = parts[index];
+        if (part === '--repo' && index + 1 < parts.length) {
+            repoName = parts[index + 1];
+            index++;
+            continue;
+        }
+        if (part === '--repo-url' && index + 1 < parts.length) {
+            repoUrl = parts[index + 1];
+            index++;
+            continue;
+        }
+        remaining.push(part);
+    }
+
+    const branchBase = remaining[0];
+    const message = remaining.slice(1).join(' ') || branchBase || 'update';
+    const knownRepos = Array.isArray(savedRepos) ? savedRepos : [];
+
+    let targetRepo = null;
+    if (repoUrl) {
+        targetRepo = {name: repoName || 'origin', url: repoUrl};
+    } else if (repoName) {
+        targetRepo = knownRepos.find((repo) => repo.name === repoName) || null;
+    } else {
+        const currentRemote = await getRemoteUrl();
+        if (currentRemote) {
+            targetRepo = knownRepos.find((repo) => repo.url === currentRemote) || {name: 'origin', url: currentRemote};
+        } else if (knownRepos.length === 1) {
+            targetRepo = knownRepos[0];
+        } else if (knownRepos.length > 1 && rl && typeof rl.question === 'function') {
+            console.log('\nAvailable repositories:');
+            knownRepos.forEach((repo, index) => console.log(`${index + 1}. ${repo.name} (${repo.url})`));
+            const answer = await new Promise((resolve) => rl.question('Select repository (number): ', resolve));
+            const selectedIndex = Number.parseInt(answer, 10) - 1;
+            if (selectedIndex >= 0 && selectedIndex < knownRepos.length) {
+                targetRepo = knownRepos[selectedIndex];
+            }
+        }
+    }
+
+    if (!targetRepo || !targetRepo.url) {
+        console.error('Error: No target repository configured.');
+        return null;
+    }
+
+    return {
+        branchBase: branchBase || 'update',
+        message,
+        targetRepo
+    };
+}
+
+async function automatedPush(targetRepo, message, branchBase) {
+    if (!(await isGitRepo())) {
+        await initRepo();
+    }
+
+    const currentRemote = await getRemoteUrl();
+    if (!currentRemote) {
+        await setRemoteUrl(targetRepo.url, false);
+    } else if (currentRemote !== targetRepo.url) {
+        await setRemoteUrl(targetRepo.url, true);
+    }
+
+    const branch = sanitizeBranchName(branchBase);
+    let branchExisted = true;
+    try {
+        runGit(`git rev-parse --verify ${quoteShellArg(branch)}`);
+        runGit(`git checkout ${quoteShellArg(branch)}`);
+    } catch (error) {
+        branchExisted = false;
+        runGit(`git checkout -b ${quoteShellArg(branch)}`);
+    }
+
+    runGit('git add .');
+
+    let committed = true;
+    try {
+        runGit(`git commit -m ${quoteShellArg(message || 'update')}`);
+    } catch (error) {
+        const stdout = error.stdout || '';
+        const stderr = error.stderr || '';
+        const combined = `${stdout}\n${stderr}`;
+        if (!combined.includes('nothing to commit')) {
+            throw error;
+        }
+        committed = false;
+    }
+
+    runGit(`git push -u origin ${branch}`);
+
+    return {
+        branch,
+        branchExisted,
+        committed,
+        message: message || 'update',
+        remoteUrl: targetRepo.url
+    };
+}
+
+module.exports = {
+    automatedPush,
+    branchExists,
+    getPushContext,
+    getDashboardStatus,
+    getNextBranchVersion,
+    getRemoteUrl,
+    getRepoRoot,
+    initRepo,
+    isGitRepo,
+    runGit,
+    setRemoteUrl,
+    updateREADME
+};

package/lib/news.js

@@ -0,0 +1,51 @@
+const https = require('https');
+
+async function fetchArticles(query, limit, apiKey) {
+    return new Promise((resolve, reject) => {
+        let url;
+        if (query) {
+            url = `https://gnews.io/api/v4/search?q=${encodeURIComponent(query)}&max=${limit}&lang=en&apikey=${apiKey}`;
+        } else {
+            url = `https://gnews.io/api/v4/top-headlines?category=general&max=${limit}&lang=en&apikey=${apiKey}`;
+        }
+
+        https.get(url, (res) => {
+            let data = '';
+            res.on('data', (chunk) => {
+                data += chunk;
+            });
+
+            res.on('end', () => {
+                if (res.statusCode === 401 || res.statusCode === 403) {
+                    return resolve({ error: 'AUTH_ERROR' });
+                }
+
+                try {
+                    const json = JSON.parse(data);
+                    
+                    if (res.statusCode !== 200) {
+                        const errorMsg = json.errors ? json.errors.join(', ') : 'Unknown error';
+                        if (errorMsg.toLowerCase().includes('api key')) {
+                            return resolve({ error: 'AUTH_ERROR' });
+                        }
+                        return reject(new Error(errorMsg));
+                    }
+
+                    if (json.articles) {
+                        resolve({ articles: json.articles });
+                    } else {
+                        resolve({ articles: [] });
+                    }
+                } catch (e) {
+                    reject(new Error('Failed to parse news data'));
+                }
+            });
+        }).on('error', (err) => {
+            reject(err);
+        });
+    });
+}
+
+module.exports = {
+    fetchArticles
+};

package/lib/storage.js

@@ -0,0 +1,119 @@
+const fs = require('fs/promises');
+const os = require('os');
+const path = require('path');
+
+const CONFIG_ENV_VAR = 'ERROR_UX_CONFIG_FILE';
+const DEFAULT_CONFIG_FILE = path.join(os.homedir(), '.error-ux', 'config.json');
+const LEGACY_CONFIG_FILE = path.join(os.homedir(), '.mycli_config.json');
+
+function getConfigFile() {
+    const override = process.env[CONFIG_ENV_VAR];
+    return override ? path.resolve(override) : DEFAULT_CONFIG_FILE;
+}
+
+function getCandidateConfigFiles() {
+    return [...new Set([getConfigFile(), LEGACY_CONFIG_FILE])];
+}
+
+function normalizeConfig(config) {
+    if (!config || typeof config !== 'object') {
+        return null;
+    }
+
+    if (!config.users || typeof config.users !== 'object') {
+        const oldName = String(config.name || 'Aniruth').trim() || 'Aniruth';
+        config = {
+            activeUser: oldName,
+            users: {
+                [oldName]: {
+                    password_hash: config.password_hash || '',
+                    news_api_key: config.news_api_key || null,
+                    shortcuts: config.shortcuts || {},
+                    activeRepo: config.activeRepo || null,
+                    savedRepos: Array.isArray(config.savedRepos) ? config.savedRepos : [],
+                    todo: Array.isArray(config.todo) ? config.todo : []
+                }
+            }
+        };
+    }
+
+    const usernames = Object.keys(config.users);
+    if (!config.activeUser || !config.users[config.activeUser]) {
+        config.activeUser = usernames[0] || null;
+    }
+
+    usernames.forEach((username) => {
+        const user = config.users[username] || {};
+        user.shortcuts = user.shortcuts && typeof user.shortcuts === 'object' ? user.shortcuts : {};
+        user.savedRepos = Array.isArray(user.savedRepos) ? user.savedRepos : [];
+        user.todo = Array.isArray(user.todo) ? user.todo : [];
+        user.activeRepo = user.activeRepo || null;
+        user.news_api_key = user.news_api_key || null;
+        user.password_hash = user.password_hash || '';
+        config.users[username] = user;
+    });
+
+    return config;
+}
+
+async function saveConfig(config) {
+    if (!config) return;
+
+    const targetFile = getConfigFile();
+    await fs.mkdir(path.dirname(targetFile), {recursive: true});
+    await fs.writeFile(targetFile, JSON.stringify(config, null, 2), 'utf8');
+}
+
+async function loadConfig() {
+    for (const candidate of getCandidateConfigFiles()) {
+        try {
+            const data = await fs.readFile(candidate, 'utf8');
+            const normalized = normalizeConfig(JSON.parse(data));
+            if (!normalized) return null;
+
+            if (candidate !== getConfigFile()) {
+                await saveConfig(normalized);
+            } else if (!normalized.users || !normalized.users[normalized.activeUser]) {
+                await saveConfig(normalized);
+            }
+
+            return normalized;
+        } catch (error) {
+            if (error.code === 'ENOENT') continue;
+            throw error;
+        }
+    }
+
+    return null;
+}
+
+function getActiveUser(config) {
+    if (!config || !config.users || !config.activeUser) return null;
+    return config.users[config.activeUser] || null;
+}
+
+async function wipeAllData() {
+    let removed = false;
+
+    for (const candidate of getCandidateConfigFiles()) {
+        try {
+            await fs.unlink(candidate);
+            removed = true;
+        } catch (error) {
+            if (error.code !== 'ENOENT') throw error;
+        }
+    }
+
+    return removed;
+}
+
+module.exports = {
+    CONFIG_ENV_VAR,
+    DEFAULT_CONFIG_FILE,
+    LEGACY_CONFIG_FILE,
+    getActiveUser,
+    getConfigFile,
+    loadConfig,
+    saveConfig,
+    wipeAllData
+};