ANSI Colored Logger in 50 Lines

// ANSI escape codes are simple. \x1b[31m is red, \x1b[0m is reset.
// process.stdout.isTTY is true when output is a real terminal; when piped to
// a file or another process we drop the codes so log files stay clean.

const color = (() => {
    const isTTY = (typeof process !== 'undefined' && process.stdout && process.stdout.isTTY) || false;
    const wrap = (open, close) => (s) => isTTY ? `\x1b[${open}m${s}\x1b[${close}m` : String(s);
    return {
        bold:    wrap(1, 22),
        dim:     wrap(2, 22),
        red:     wrap(31, 39),
        green:   wrap(32, 39),
        yellow:  wrap(33, 39),
        blue:    wrap(34, 39),
        magenta: wrap(35, 39),
        cyan:    wrap(36, 39),
        gray:    wrap(90, 39),
    };
})();

function stamp() {
    const d = new Date();
    return d.toISOString().slice(11, 19);
}

const logger = {
    info:  (...a) => console.log(color.gray(stamp()), color.cyan('info'),  ...a),
    warn:  (...a) => console.log(color.gray(stamp()), color.yellow('warn'),  ...a),
    error: (...a) => console.error(color.gray(stamp()), color.red('error'), ...a),
    ok:    (...a) => console.log(color.gray(stamp()), color.green('ok'),    ...a),
    step:  (label, fn) => {
        console.log(color.gray(stamp()), color.blue('step'), color.bold(label));
        return fn();
    },
};

logger.info('starting build');
logger.step('compile', () => {
    logger.info('compiling lib/');
    logger.warn('deprecated import detected in lib/legacy.js');
});
logger.ok('build complete');
logger.error('but tests failed');

// Two more 'right defaults' that production CLIs need.
// 1. NO_COLOR=1 environment variable, the cross-tool standard for disabling color.
// 2. LOG_LEVEL=error to silence info/warn at runtime.

function makeLogger() {
    const env = (typeof process !== 'undefined' && process.env) || {};
    const isTTY = (typeof process !== 'undefined' && process.stdout && process.stdout.isTTY) || false;
    const colorOn = isTTY && !env.NO_COLOR;
    const level = (env.LOG_LEVEL || 'info').toLowerCase();
    const order = { error: 0, warn: 1, info: 2, debug: 3 };
    const threshold = order[level] !== undefined ? order[level] : 2;

    const wrap = (open, close) => (s) => colorOn ? `\x1b[${open}m${s}\x1b[${close}m` : String(s);
    const c = {
        red:    wrap(31, 39),
        yellow: wrap(33, 39),
        cyan:   wrap(36, 39),
        gray:   wrap(90, 39),
    };

    const stamp = () => new Date().toISOString().slice(11, 19);
    const at = (lvl) => order[lvl] <= threshold;

    return {
        debug: (...a) => at('debug') && console.log(c.gray(stamp()), c.gray('debug'), ...a),
        info:  (...a) => at('info')  && console.log(c.gray(stamp()), c.cyan('info'),  ...a),
        warn:  (...a) => at('warn')  && console.log(c.gray(stamp()), c.yellow('warn'), ...a),
        error: (...a) => at('error') && console.error(c.gray(stamp()), c.red('error'), ...a),
    };
}

const logger = makeLogger();
logger.debug('this is suppressed at default level');
logger.info('hello');
logger.warn('something off');
logger.error('oh no');

process.env.NO_COLOR = '1';
const plain = makeLogger();
plain.info('this line has no escape codes');
plain.error('and this one has no red');

// One thing chalk does not give you: a progress line that updates in place.
// Use \r (carriage return) to move the cursor to start-of-line, then write
// the new line. \x1b[K clears from cursor to end-of-line so a shorter line
// cleanly overwrites a longer previous one.

function makeProgress(label) {
    const isTTY = (typeof process !== 'undefined' && process.stdout && process.stdout.isTTY) || false;
    return {
        update(message) {
            if (!isTTY) {
                console.log(`${label}: ${message}`);
                return;
            }
            process.stdout.write('\r\x1b[K' + `${label}: ${message}`);
        },
        done(finalMessage) {
            if (!isTTY) {
                console.log(`${label}: ${finalMessage}`);
                return;
            }
            process.stdout.write('\r\x1b[K' + `${label}: ${finalMessage}\n`);
        },
    };
}

const p = makeProgress('build');
let step = 0;
const phases = ['scanning sources', 'compiling lib/', 'compiling app/', 'linking', 'writing manifest'];
const tick = () => {
    p.update(`${phases[step]} (${step + 1}/${phases.length})`);
    step += 1;
    if (step < phases.length) setTimeout(tick, 80);
    else p.done(`completed in ${(phases.length * 0.08).toFixed(2)}s`);
};
tick();