preva-cli 0.0.0-stage → 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 gozajpeg
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,172 @@
-# Temporary Holding Version
+<div align="center">
+  <img src="https://raw.githubusercontent.com/gozajpeg/preva/main/assets/preva.webp" alt="preva logo" width="380" />
+  <h1>preva</h1>
+  <p><strong>Same Git, just with a preview.</strong></p>
+  <p>Preva doesn't change how Git works. It just shows you what's happening before you stage, commit, or push, so you can catch mistakes before they leave your machine.</p>
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+  <p>
+    <a href="https://nodejs.org"><img src="https://img.shields.io/badge/node-%3E%3D18.0.0-brightgreen.svg?style=flat-square" alt="node version" /></a>
+    <a href="https://www.npmjs.com/package/preva-cli"><img src="https://img.shields.io/badge/npm-preva--cli-red.svg?style=flat-square" alt="npm package" /></a>
+    <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue.svg?style=flat-square" alt="license" /></a>
+    <a href="https://github.com/gozajpeg"><img src="https://img.shields.io/badge/author-gozajpeg-blue.svg?style=flat-square" alt="author" /></a>
+  </p>
+</div>
+
+---
+
+### Overview
+
+Preva doesn't change how Git works. It runs normal Git commands, but gives you a preview first so you don't push the wrong files by accident:
+
+1. **Interactive Staging (`preva add`)**: Pick which files to stage from a checklist instead of running `git add .` blindly. Common secret files like `.env` start unchecked.
+2. **Conventional Commits (`preva commit`)**: Pick standard commit types (`feat`, `fix`, `docs`, etc.) to keep your commit history clean and consistent.
+3. **Pre-Push Review (`preva push`)**: See your unpushed commits and the exact files you're about to push, with an alert if any secret files got committed.
+
+---
+
+### Terminal Previews
+
+#### 1. Interactive Staging (`preva git add .`)
+
+Instead of staging everything blindly with `git add .`, run:
+
+```bash
+preva git add .
+# or shorthand:
+preva add .
+```
+
+`preva` scans your repository changes and displays an interactive checklist:
+
+![preva git add preview](https://raw.githubusercontent.com/gozajpeg/preva/main/assets/add.webp)
+
+- **Normal changes** start pre-checked so common staging stays fast.
+- **Sensitive files** (patterns like `*.key`, `*.pem`, `.env*`, `credentials.json`, `*.p12`) start **unchecked** by default.
+- Use **arrow keys** or **j/k** to navigate, **Space** to toggle, **a** to toggle all, and **Enter** to confirm.
+- Only the files you confirm will be staged with native `git add`.
+
+You can also target specific folders or paths:
+
+```bash
+preva git add src/
+preva git add config/
+```
+
+---
+
+#### 2. Conventional Commit Generator (`preva git commit`)
+
+Write clean, consistent Conventional Commits with interactive selectable types and pre-filled formatting:
+
+```bash
+preva git commit
+# or shorthand:
+preva commit
+```
+
+`preva` reviews your staged changes, lets you select standard commit types, prompts for an optional scope, and previews the formatted message:
+
+![preva git commit preview](https://raw.githubusercontent.com/gozajpeg/preva/main/assets/commit.webp)
+
+- **Standard Types**: Pre-fills the 11 standard types from Conventional Commits v1.0.0 and `@commitlint/config-conventional`.
+- **Automatic Formatting**: Normalizes scopes to lowercase and auto-strips trailing periods so commits pass CI linters without friction.
+- **Breaking Changes**: Automatically appends the standard exclamation mark `!` (e.g. `feat(api)!: remove v1 endpoint`) when a breaking change is confirmed.
+- **Safety**: Warns if nothing is staged and suggests running `preva git add .` first.
+- **Flag Pass-through**: Passes through native Git commit flags (e.g. `preva commit --amend` or `preva commit -m "custom message"`).
+
+---
+
+#### 3. Pre-Push Review (`preva git push`)
+
+Before pushing your branch, run:
+
+```bash
+preva git push origin main
+# or shorthand:
+preva push
+```
+
+`preva` inspects the unpushed commits and presents a clear summary:
+
+![preva git push preview](https://raw.githubusercontent.com/gozajpeg/preva/main/assets/push.webp)
+
+- If flagged files are detected, the confirmation prompt defaults to **No (`[y/N]`)**.
+- Pressing **n**, **Enter**, or **Ctrl+C** cleanly cancels the push without sending anything to the remote.
+- When cancelled, `preva` prints the command to uncommit the file if you need to adjust it:
+  ```bash
+  To uncommit and adjust before pushing:
+     git reset --soft HEAD~1
+     preva git add .
+     preva commit
+  ```
+
+---
+
+### What `preva` Flags
+
+1. **Common Sensitive Patterns:** Identifies common credential and key formats by filename (`.env*`, `*.pem`, `*.key`, `id_rsa*`, `credentials.json`, `*.p12`, `*.keystore`, `*.p8`, `*.ovpn`, `.npmrc`, `.pypirc`).
+2. **Tracked `.gitignore` Matches:** Flags files that match your project's `.gitignore` rules but are still being tracked because they were committed previously.
+3. **Heavy Directories:** Highlights unignored directories such as `node_modules/` or `dist/` before they are staged.
+4. **Renamed and Deleted Files:** Distinguishes renames (`R`) and deletions (`D`) in the checklist.
+
+---
+
+### Boundaries (What `preva` Is Not)
+
+- **Not a Secret Scanner:** `preva` checks file names and paths against known patterns. It does not scan inside file contents for hardcoded tokens or API keys.
+- **No Automatic History Alterations:** `preva` will never automatically rebase, reset, or amend commits for you.
+- **No Native Git Interception:** It does not install Git hooks. Plain `git add` and `git push` will continue to run without `preva` unless explicitly invoked.
+
+---
+
+### Installation & Usage
+
+Install globally via npm:
+
+```bash
+npm install -g preva-cli
+```
+
+Or run directly with `npx`:
+
+```bash
+npx preva-cli git add .
+```
+
+#### Commands
+
+| Command | Description |
+|---|---|
+| `preva git add .` | Review all changes in an interactive checklist before staging |
+| `preva git add <paths...>` | Review specific files or folders before staging |
+| `preva git commit` | Interactive Conventional Commit generator with selectable types |
+| `preva git push [remote] [branch]` | Review unpushed commits and files before pushing |
+| `preva --version` | Show installed version |
+| `preva --help` | Show usage help and options |
+
+---
+
+### Non-Interactive Environments & CI
+
+When run in environments without an interactive TTY (`!process.stdin.isTTY`):
+- `preva` detects the missing terminal and exits cleanly with code `1` rather than hanging.
+
+| Exit Code | Meaning |
+|---|---|
+| `0` | Success: files staged or commits pushed |
+| `1` | Error: not a git repo, no changes, or non-interactive terminal |
+| `130` | Cancelled by user (`Ctrl+C` or chose `N`) |
+
+---
+
+### Design Philosophy
+
+- **Zero External Dependencies:** Built entirely with Node.js standard library built-ins (`node:readline`, `node:child_process`, `node:fs`, `node:path`).
+- **Zero Extra Config Files:** No `.prevaignore` dotfiles required. Works using built-in patterns and your project's `.gitignore`.
+- **Defensive Execution:** Runs native Git commands using `execFile` with argument arrays and `--` path separators to avoid shell quoting and flag injection issues.
+
+---
+
+### License
+
+MIT License © [gozajpeg](https://github.com/gozajpeg)

package/bin/preva.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+
+import { main } from '../src/index.js';
+
+main().catch((err) => {
+  if (err && err.message) {
+    console.error(err.message);
+  }
+  process.exit(1);
+});

package/package.json

@@ -1,6 +1,43 @@
 {
   "name": "preva-cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "1.0.1",
+  "description": "Same Git, just with a preview.",
+  "type": "module",
+  "main": "src/index.js",
+  "bin": {
+    "preva": "bin/preva.js"
+  },
+  "files": [
+    "bin",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "node --test test/**/*.test.js"
+  },
+  "keywords": [
+    "git",
+    "git-add",
+    "git-push",
+    "preview",
+    "staging",
+    "guard",
+    "checklist",
+    "developer-tools",
+    "zero-dependency"
+  ],
+  "author": "gozajpeg",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gozajpeg/preva.git"
+  },
+  "bugs": {
+    "url": "https://github.com/gozajpeg/preva/issues"
+  },
+  "homepage": "https://github.com/gozajpeg/preva#readme",
+  "engines": {
+    "node": ">=18.0.0"
+  }
 }

package/src/commands/add.js

@@ -0,0 +1,54 @@
+import { isGitRepo, getChangedFiles, stageFiles, getRepoRoot } from '../utils/git.js';
+import { scanFiles } from '../utils/scanner.js';
+import { checkboxList } from '../utils/ui.js';
+import { colors } from '../utils/colors.js';
+
+export async function addCommand(paths = []) {
+  const isRepo = await isGitRepo();
+  if (!isRepo) {
+    console.error(colors.red('Error: Not a git repository (or any of the parent directories).'));
+    process.exit(1);
+  }
+
+  const repoRoot = await getRepoRoot().catch(() => process.cwd());
+  const changed = await getChangedFiles(paths);
+
+  if (changed.length === 0) {
+    console.log(colors.dim('Nothing to stage (working tree clean).'));
+    process.exit(0);
+  }
+
+  const scanned = scanFiles(changed, repoRoot);
+
+  const choices = scanned.map((file) => ({
+    name: file.path,
+    value: file.path,
+    checked: file.defaultChecked,
+    flagged: file.flagged,
+    reason: file.reason,
+    status: file.status,
+  }));
+
+  const selected = await checkboxList({
+    message: 'Select files to stage:',
+    choices,
+  });
+
+  if (selected.length === 0) {
+    console.log(colors.yellow('No files selected. Nothing staged.'));
+    process.exit(0);
+  }
+
+  try {
+    await stageFiles(selected);
+    const leftUnstaged = changed.length - selected.length;
+    const summaryMsg =
+      leftUnstaged > 0
+        ? ` (${leftUnstaged} left unstaged)`
+        : '';
+    console.log(`Staged ${colors.bold(selected.length)} file(s)${summaryMsg}.`);
+  } catch (err) {
+    console.error(colors.red(`Error staging files: ${err.message}`));
+    process.exit(1);
+  }
+}

package/src/commands/commit.js

@@ -0,0 +1,138 @@
+import { isGitRepo, getStagedFiles, commitStaged } from '../utils/git.js';
+import { selectPrompt, inputPrompt, confirmPrompt } from '../utils/ui.js';
+import { colors } from '../utils/colors.js';
+
+export const COMMIT_TYPES = [
+  { value: 'feat', name: 'feat:     A new feature' },
+  { value: 'fix', name: 'fix:      A bug fix' },
+  { value: 'docs', name: 'docs:     Documentation only changes' },
+  { value: 'style', name: 'style:    Changes that do not affect code logic (formatting, white-space)' },
+  { value: 'refactor', name: 'refactor: A code change that neither fixes a bug nor adds a feature' },
+  { value: 'perf', name: 'perf:     A code change that improves performance' },
+  { value: 'test', name: 'test:     Adding missing tests or correcting existing tests' },
+  { value: 'build', name: 'build:    Changes affecting build system or external dependencies' },
+  { value: 'ci', name: 'ci:       Changes to CI configuration files and scripts' },
+  { value: 'chore', name: 'chore:    Other changes that do not modify src or test files' },
+  { value: 'revert', name: 'revert:   Reverts a previous commit' },
+];
+
+/**
+ * Format type, optional scope, and message into Conventional Commit standard.
+ * Adheres strictly to Conventional Commits v1.0.0 and @commitlint/config-conventional:
+ * - <type>(<scope>): <message>
+ * - lowercase scope
+ * - no trailing period
+ * - optional breaking change '!' indicator before colon
+ */
+export function formatCommitMessage(type, scope, message, isBreaking = false) {
+  const cleanScope = scope ? scope.trim().toLowerCase() : '';
+  let cleanMsg = message ? message.trim() : '';
+  if (cleanMsg.endsWith('.')) {
+    cleanMsg = cleanMsg.slice(0, -1).trim();
+  }
+  const bang = isBreaking ? '!' : '';
+  if (cleanScope) {
+    return `${type}(${cleanScope})${bang}: ${cleanMsg}`;
+  }
+  return `${type}${bang}: ${cleanMsg}`;
+}
+
+export async function commitCommand(args = []) {
+  const isRepo = await isGitRepo();
+  if (!isRepo) {
+    console.error(colors.red('Error: Not a git repository (or any of the parent directories).'));
+    process.exit(1);
+  }
+
+  // If user already passed a commit message via -m or --message, execute git commit directly
+  const hasMsgFlag = args.includes('-m') || args.includes('--message');
+  if (hasMsgFlag) {
+    try {
+      const { stdout } = await commitStaged('', args);
+      console.log(stdout.trim());
+      return;
+    } catch (err) {
+      console.error(colors.red(`Commit failed: ${err.message}`));
+      process.exit(1);
+    }
+  }
+
+  // Check if staged changes exist
+  const staged = await getStagedFiles();
+  const hasOverrideFlags =
+    args.includes('-a') ||
+    args.includes('--all') ||
+    args.includes('--allow-empty') ||
+    args.includes('--amend');
+
+  if (staged.length === 0 && !hasOverrideFlags) {
+    console.log(colors.yellow('No staged changes to commit.'));
+    console.log(`Stage changes first using: ${colors.cyan('preva git add .')}\n`);
+    process.exit(0);
+  }
+
+  // Show staged files summary
+  if (staged.length > 0) {
+    console.log(`\n${colors.bold('Staged changes')} (${colors.cyan(staged.length)}):`);
+    staged.slice(0, 10).forEach((f) => {
+      let badge = colors.cyan('M');
+      if (f.status === 'new') badge = colors.green('A');
+      else if (f.status === 'deleted') badge = colors.red('D');
+      else if (f.status === 'renamed') badge = colors.yellow('R');
+      console.log(`  • ${badge} ${f.path}`);
+    });
+    if (staged.length > 10) {
+      console.log(colors.dim(`  ... and ${staged.length - 10} more files`));
+    }
+    console.log('');
+  }
+
+  // 1. Select Conventional Commit Type
+  const type = await selectPrompt({
+    message: 'Select commit type:',
+    choices: COMMIT_TYPES,
+  });
+
+  // 2. Input Scope (optional)
+  const scope = await inputPrompt({
+    message: 'Scope (optional, e.g. auth, api, ui)',
+    placeholder: 'press enter to skip',
+    allowEmpty: true,
+  });
+
+  // 3. Input Commit Message Description
+  const message = await inputPrompt({
+    message: 'Commit message',
+    placeholder: 'imperative, e.g. add user login',
+    allowEmpty: false,
+  });
+
+  // 4. Breaking change check
+  const isBreaking = await confirmPrompt({
+    message: 'Is this a breaking change?',
+    defaultValue: false,
+  });
+
+  const fullMessage = formatCommitMessage(type, scope, message, isBreaking);
+
+  // 5. Preview and Confirm
+  console.log(`\n${colors.bold('Commit preview:')} ${colors.green(fullMessage)}`);
+
+  const proceed = await confirmPrompt({
+    message: 'Create this commit?',
+    defaultValue: true,
+  });
+
+  if (!proceed) {
+    console.log(colors.dim('\nCommit cancelled. Nothing committed.'));
+    process.exit(130);
+  }
+
+  try {
+    const { stdout } = await commitStaged(fullMessage, args);
+    console.log(`\n${stdout.trim()}`);
+  } catch (err) {
+    console.error(colors.red(`Commit failed: ${err.message}`));
+    process.exit(1);
+  }
+}

package/src/commands/push.js

@@ -0,0 +1,98 @@
+import { isGitRepo, getUnpushedCommits, getUnpushedFiles, pushCommits } from '../utils/git.js';
+import { scanFiles } from '../utils/scanner.js';
+import { confirmPrompt } from '../utils/ui.js';
+import { colors } from '../utils/colors.js';
+
+export async function pushCommand(args = []) {
+  const isRepo = await isGitRepo();
+  if (!isRepo) {
+    console.error(colors.red('Error: Not a git repository (or any of the parent directories).'));
+    process.exit(1);
+  }
+
+  // Parse remote and branch if provided (ignoring flags like -u, --force, etc.)
+  const nonFlagArgs = args.filter((a) => !a.startsWith('-'));
+  const remote = nonFlagArgs[0] || null;
+  const branch = nonFlagArgs[1] || null;
+
+  const { commits, upstreamRef, noCommits } = await getUnpushedCommits(process.cwd(), remote, branch);
+
+  if (noCommits) {
+    console.log(colors.yellow('No commits on current branch yet. Create a commit first with git commit.'));
+    process.exit(0);
+  }
+
+  if (commits.length === 0) {
+    console.log(colors.dim('Everything up-to-date. No commits to push.'));
+    process.exit(0);
+  }
+
+  const unpushedFiles = await getUnpushedFiles(process.cwd(), upstreamRef, commits);
+  const scannedFiles = scanFiles(unpushedFiles);
+  const flaggedFiles = scannedFiles.filter((f) => f.flagged);
+
+  // 1. Commits preview
+  console.log(`\n${colors.bold('Unpushed Commits')} (${colors.cyan(commits.length)}):`);
+  commits.slice(0, 10).forEach((c) => {
+    console.log(`  • ${colors.yellow(c.hash)} ${c.message} ${colors.dim(`(${c.author})`)}`);
+  });
+  if (commits.length > 10) {
+    console.log(colors.dim(`  ... and ${commits.length - 10} more commits`));
+  }
+
+  // 2. Files preview
+  console.log(`\n${colors.bold('Files leaving your machine')} (${colors.cyan(scannedFiles.length)}):`);
+  scannedFiles.slice(0, 20).forEach((f) => {
+    let statusBadge = colors.cyan('M');
+    if (f.status === 'new') statusBadge = colors.green('A');
+    else if (f.status === 'deleted') statusBadge = colors.red('D');
+    else if (f.status === 'renamed') statusBadge = colors.yellow('R');
+
+    let flagBadge = '';
+    if (f.flagged) {
+      flagBadge = colors.yellow(`  [FLAGGED: ${f.reason || 'sensitive'}]`);
+    }
+
+    console.log(`  • ${statusBadge} ${f.path}${flagBadge}`);
+  });
+  if (scannedFiles.length > 20) {
+    console.log(colors.dim(`  ... and ${scannedFiles.length - 20} more files`));
+  }
+
+  console.log('');
+
+  // 3. Flagged warning
+  if (flaggedFiles.length > 0) {
+    console.log(
+      colors.yellow(
+        `Notice: ${colors.bold(flaggedFiles.length)} flagged file(s) detected in unpushed commits.`
+      )
+    );
+  }
+
+  const targetName = remote && branch ? `${remote}/${branch}` : upstreamRef || 'remote';
+  const shouldDefaultNo = flaggedFiles.length > 0;
+
+  const proceed = await confirmPrompt({
+    message: `Push ${commits.length} commit(s) to ${targetName}?`,
+    defaultValue: !shouldDefaultNo,
+  });
+
+  if (!proceed) {
+    console.log(colors.dim('\nPush cancelled. No commits or files were pushed.'));
+    if (flaggedFiles.length > 0) {
+      console.log(`\n${colors.bold('To uncommit and adjust before pushing:')}`);
+      console.log(`   ${colors.cyan('git reset --soft HEAD~1')}`);
+      console.log(`   ${colors.cyan('preva git add .')}`);
+      console.log(`   ${colors.cyan('git commit -m "your message"')}\n`);
+    }
+    process.exit(130);
+  }
+
+  try {
+    await pushCommits(args);
+  } catch (err) {
+    console.error(colors.red(`Push failed: ${err.message}`));
+    process.exit(1);
+  }
+}

package/src/index.js

@@ -0,0 +1,83 @@
+import { readFileSync } from 'node:fs';
+import { addCommand } from './commands/add.js';
+import { commitCommand } from './commands/commit.js';
+import { pushCommand } from './commands/push.js';
+import { colors } from './utils/colors.js';
+
+function getVersion() {
+  try {
+    const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+    return pkg.version;
+  } catch {
+    return '0.1.0';
+  }
+}
+
+function printHelp() {
+  console.log(`
+${colors.bold('preva')} - Interactive Git Staging, Commit & Push Preview Guard
+
+${colors.bold('USAGE:')}
+  ${colors.cyan('preva git add')} [paths...]          Review and select files before staging
+  ${colors.cyan('preva git commit')} [args...]        Interactive Conventional Commit generator
+  ${colors.cyan('preva git push')} [remote] [branch]  Preview commits and files before pushing
+  ${colors.cyan('preva')} --version                   Show version
+  ${colors.cyan('preva')} --help                      Show this help message
+
+${colors.bold('EXAMPLES:')}
+  $ preva git add .
+  $ preva git commit
+  $ preva git push origin main
+
+${colors.dim('Zero external dependencies. Pure Node.js.')}
+`);
+}
+
+export async function main(argv = process.argv.slice(2)) {
+  if (argv.length === 0 || argv.includes('--help') || argv.includes('-h')) {
+    printHelp();
+    return;
+  }
+
+  if (argv.includes('--version') || argv.includes('-v')) {
+    console.log(getVersion());
+    return;
+  }
+
+  const [first, second, ...rest] = argv;
+
+  // Handle "git add" or shorthand "add"
+  if (first === 'git' && second === 'add') {
+    await addCommand(rest);
+    return;
+  }
+  if (first === 'add') {
+    await addCommand([second, ...rest].filter(Boolean));
+    return;
+  }
+
+  // Handle "git commit" or shorthand "commit"
+  if (first === 'git' && second === 'commit') {
+    await commitCommand(rest);
+    return;
+  }
+  if (first === 'commit') {
+    await commitCommand([second, ...rest].filter(Boolean));
+    return;
+  }
+
+  // Handle "git push" or shorthand "push"
+  if (first === 'git' && second === 'push') {
+    await pushCommand(rest);
+    return;
+  }
+  if (first === 'push') {
+    await pushCommand([second, ...rest].filter(Boolean));
+    return;
+  }
+
+  console.error(
+    colors.red(`Unknown command: ${argv.join(' ')}\nRun "${colors.cyan('preva --help')}" for usage instructions.`)
+  );
+  process.exit(1);
+}

package/src/utils/colors.js

@@ -0,0 +1,27 @@
+// Zero-dependency terminal colors supporting NO_COLOR and TTY detection
+
+const isColorSupported =
+  !process.env.NO_COLOR &&
+  (process.stdout.isTTY || process.env.FORCE_COLOR !== undefined);
+
+function style(start, end) {
+  return (str) => (isColorSupported ? `\x1b[${start}m${str}\x1b[${end}m` : String(str));
+}
+
+export const colors = {
+  reset: isColorSupported ? '\x1b[0m' : '',
+  bold: style(1, 22),
+  dim: style(2, 22),
+  italic: style(3, 23),
+  underline: style(4, 24),
+  red: style(31, 39),
+  green: style(32, 39),
+  yellow: style(33, 39),
+  blue: style(34, 39),
+  magenta: style(35, 39),
+  cyan: style(36, 39),
+  white: style(37, 39),
+  gray: style(90, 39),
+  bgRed: style(41, 49),
+  bgYellow: style(43, 49),
+};