dbn-cli 0.4.0 → 0.5.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dbn-cli",
-  "version": "0.4.0",
+  "version": "0.5.2",
   "description": "A lightweight terminal-based database browser",
   "repository": "https://github.com/amio/dbn-cli",
   "type": "module",
@@ -9,10 +9,10 @@
     "dbn": "bin/dbn.ts"
   },
   "scripts": {
-    "test": "node --test --experimental-strip-types test/*.test.ts",
-    "test:watch": "node --test --watch --experimental-strip-types test/*.test.ts",
-    "test:coverage": "node --test --experimental-test-coverage --experimental-strip-types test/*.test.ts",
-    "dev": "node bin/dbp.ts"
+    "test": "node --test --experimental-strip-types src/**/*.test.ts src/*.test.ts",
+    "test:watch": "node --test --watch --experimental-strip-types src/**/*.test.ts src/*.test.ts",
+    "test:coverage": "node --test --experimental-test-coverage --experimental-strip-types src/**/*.test.ts src/*.test.ts",
+    "dev": "node bin/dbn.ts"
   },
   "keywords": [
     "database",

package/src/adapter/adapter.test.ts

@@ -0,0 +1,207 @@
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert';
+import { DatabaseSync } from 'node:sqlite';
+import { existsSync, unlinkSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { SQLiteAdapter } from '../adapter/sqlite.ts';
+
+const TEST_DB = join(tmpdir(), 'dbn-cli-test.db');
+
+/**
+ * Set up test database
+ */
+function setupTestDB(): void {
+  // Remove old test db if exists
+  if (existsSync(TEST_DB)) {
+    unlinkSync(TEST_DB);
+  }
+
+  // Create test database
+  const db = new DatabaseSync(TEST_DB);
+  
+  // Create test tables
+  db.exec(`
+    CREATE TABLE users (
+      id INTEGER PRIMARY KEY,
+      name TEXT NOT NULL,
+      email TEXT,
+      age INTEGER
+    );
+  `);
+
+  db.exec(`
+    CREATE TABLE posts (
+      id INTEGER PRIMARY KEY,
+      user_id INTEGER,
+      title TEXT NOT NULL,
+      content TEXT,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    );
+  `);
+
+  // Insert test data
+  const insertUser = db.prepare('INSERT INTO users (name, email, age) VALUES (?, ?, ?)');
+  insertUser.run('Alice', 'alice@example.com', 30);
+  insertUser.run('Bob', 'bob@example.com', 25);
+  insertUser.run('Charlie', 'charlie@example.com', 35);
+
+  const insertPost = db.prepare('INSERT INTO posts (user_id, title, content) VALUES (?, ?, ?)');
+  insertPost.run(1, 'Hello World', 'This is my first post');
+  insertPost.run(1, 'Second Post', 'Another post by Alice');
+  insertPost.run(2, 'Bobs Post', 'Post by Bob');
+
+  db.close();
+}
+
+/**
+ * Clean up test database
+ */
+function cleanupTestDB(): void {
+  if (existsSync(TEST_DB)) {
+    unlinkSync(TEST_DB);
+  }
+}
+
+/**
+ * Test suite for SQLiteAdapter
+ */
+describe('SQLiteAdapter', () => {
+  before(() => {
+    setupTestDB();
+  });
+
+  after(() => {
+    cleanupTestDB();
+  });
+
+  it('should connect to database', () => {
+    const adapter = new SQLiteAdapter();
+    adapter.connect(TEST_DB);
+    assert.ok((adapter as any).db !== null, 'Database should be connected');
+    assert.strictEqual((adapter as any).path, TEST_DB, 'Path should be set correctly');
+    adapter.close();
+  });
+
+  it('should throw error when connecting to invalid path', () => {
+    const adapter = new SQLiteAdapter();
+    // Try to connect to an invalid path (directory that doesn't exist)
+    assert.throws(
+      () => adapter.connect('/nonexistent/path/to/database.db'),
+      /Failed to open database/,
+      'Should throw error for invalid path'
+    );
+  });
+
+  it('should get all tables', () => {
+    const adapter = new SQLiteAdapter();
+    adapter.connect(TEST_DB);
+    
+    const tables = adapter.getTables();
+    assert.strictEqual(tables.length, 2, 'Should have 2 tables');
+    assert.strictEqual(tables[0].name, 'posts', 'First table should be posts');
+    assert.strictEqual(tables[1].name, 'users', 'Second table should be users');
+    assert.ok(tables[0].row_count !== undefined, 'Should have row_count property');
+    
+    adapter.close();
+  });
+
+  it('should get table schema', () => {
+    const adapter = new SQLiteAdapter();
+    adapter.connect(TEST_DB);
+    
+    const schema = adapter.getTableSchema('users');
+    assert.strictEqual(schema.length, 4, 'Users table should have 4 columns');
+    assert.strictEqual(schema[0].name, 'id', 'First column should be id');
+    assert.strictEqual(schema[0].type, 'INTEGER', 'ID should be INTEGER');
+    assert.strictEqual(schema[0].pk, 1, 'ID should be primary key');
+    assert.strictEqual(schema[1].name, 'name', 'Second column should be name');
+    assert.strictEqual(schema[1].type, 'TEXT', 'Name should be TEXT');
+    assert.strictEqual(schema[1].notnull, 1, 'Name should be NOT NULL');
+    
+    adapter.close();
+  });
+
+  it('should get table data', () => {
+    const adapter = new SQLiteAdapter();
+    adapter.connect(TEST_DB);
+    
+    const data = adapter.getTableData('users');
+    assert.strictEqual(data.length, 3, 'Should have 3 users');
+    assert.strictEqual(data[0].name, 'Alice', 'First user should be Alice');
+    assert.strictEqual(data[0].email, 'alice@example.com', 'Alice email should match');
+    assert.strictEqual(data[0].age, 30, 'Alice age should be 30');
+    
+    adapter.close();
+  });
+
+  it('should get table data with pagination', () => {
+    const adapter = new SQLiteAdapter();
+    adapter.connect(TEST_DB);
+    
+    // Get 2 rows starting from offset 1
+    const data = adapter.getTableData('users', { limit: 2, offset: 1 });
+    assert.strictEqual(data.length, 2, 'Should return 2 users');
+    assert.strictEqual(data[0].name, 'Bob', 'First result should be Bob');
+    assert.strictEqual(data[1].name, 'Charlie', 'Second result should be Charlie');
+    
+    adapter.close();
+  });
+
+  it('should get table data with custom limit', () => {
+    const adapter = new SQLiteAdapter();
+    adapter.connect(TEST_DB);
+    
+    const data = adapter.getTableData('users', { limit: 1 });
+    assert.strictEqual(data.length, 1, 'Should return 1 user');
+    assert.strictEqual(data[0].name, 'Alice', 'Should return Alice');
+    
+    adapter.close();
+  });
+
+  it('should get row count', () => {
+    const adapter = new SQLiteAdapter();
+    adapter.connect(TEST_DB);
+    
+    const userCount = adapter.getRowCount('users');
+    assert.strictEqual(userCount, 3, 'Should have 3 users');
+    
+    const postCount = adapter.getRowCount('posts');
+    assert.strictEqual(postCount, 3, 'Should have 3 posts');
+    
+    adapter.close();
+  });
+
+  it('should close database connection', () => {
+    const adapter = new SQLiteAdapter();
+    adapter.connect(TEST_DB);
+    assert.ok((adapter as any).db !== null, 'Database should be connected');
+    
+    adapter.close();
+    assert.strictEqual((adapter as any).db, null, 'Database should be null after close');
+  });
+
+  it('should handle closing when not connected', () => {
+    const adapter = new SQLiteAdapter();
+    assert.doesNotThrow(() => adapter.close(), 'Should not throw when closing unconnected adapter');
+  });
+
+  it('should delete a row', () => {
+    const adapter = new SQLiteAdapter();
+    adapter.connect(TEST_DB);
+
+    const initialCount = adapter.getRowCount('users');
+    const user = adapter.getTableData('users', { limit: 1, offset: 0 })[0];
+    assert.ok(user.id, 'User should have an id');
+
+    adapter.deleteRow('users', { id: user.id });
+
+    const newCount = adapter.getRowCount('users');
+    assert.strictEqual(newCount, initialCount - 1, 'Row count should decrease by 1');
+
+    const remainingUsers = adapter.getTableData('users');
+    assert.ok(!remainingUsers.find(u => u.id === user.id), 'Deleted user should not be in results');
+
+    adapter.close();
+  });
+});

package/src/index.ts

@@ -86,7 +86,9 @@ export class DBPeek {
    */
   private setupInput(): void {
     // Enable raw mode for key-by-key input
-    stdin.setRawMode(true);
+    if (stdin.isTTY) {
+      stdin.setRawMode(true);
+    }
     stdin.resume();
     stdin.setEncoding('utf8');
 
@@ -138,12 +140,28 @@ export class DBPeek {
         break;
 
       case 'j':
+        if (this.navigator.getState().type === 'row-detail') {
+          (this.navigator as any).nextRecord();
+        } else {
+          this.navigator.moveDown();
+        }
+        this.render();
+        break;
+
+      case 'k':
+        if (this.navigator.getState().type === 'row-detail') {
+          (this.navigator as any).prevRecord();
+        } else {
+          this.navigator.moveUp();
+        }
+        this.render();
+        break;
+
       case 'down':
         this.navigator.moveDown();
         this.render();
         break;
 
-      case 'k':
       case 'up':
         this.navigator.moveUp();
         this.render();

package/src/repro_bug.test.ts

@@ -0,0 +1,101 @@
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert';
+import { DatabaseSync } from 'node:sqlite';
+import { unlinkSync, existsSync } from 'node:fs';
+import { SQLiteAdapter } from './adapter/sqlite.ts';
+import { Navigator } from './ui/navigator.ts';
+
+const REPRO_DB = './repro-bug.db';
+
+describe('Navigator Bug Reproduction & Edge Cases', () => {
+  let adapter: SQLiteAdapter;
+  let navigator: Navigator;
+
+  before(() => {
+    const db = new DatabaseSync(REPRO_DB);
+    db.exec(`
+      CREATE TABLE items (
+        id INTEGER PRIMARY KEY,
+        name TEXT
+      );
+    `);
+
+    const insert = db.prepare('INSERT INTO items (name) VALUES (?)');
+    for (let i = 1; i <= 100; i++) {
+      insert.run(`Item ${i}`);
+    }
+    db.close();
+
+    adapter = new SQLiteAdapter();
+    adapter.connect(REPRO_DB);
+    navigator = new Navigator(adapter);
+  });
+
+  after(() => {
+    adapter.close();
+    if (existsSync(REPRO_DB)) {
+      unlinkSync(REPRO_DB);
+    }
+  });
+
+  it('should enter the correct row when scrolled down', () => {
+    navigator.init();
+    // Enter table detail for 'items'
+    navigator.enter();
+
+    let state = navigator.getState() as any;
+    assert.strictEqual(state.type, 'table-detail');
+    assert.strictEqual(state.dataCursor, 0);
+    assert.strictEqual(state.dataOffset, 0);
+
+    // Move down 30 times.
+    // Default visibleRows is 20, so this should push dataOffset to 11 (if cursor hits bottom at 19)
+    for (let i = 0; i < 30; i++) {
+      navigator.moveDown();
+    }
+
+    state = navigator.getState() as any;
+    const expectedRowIndex = state.dataOffset + state.dataCursor;
+    const expectedName = `Item ${expectedRowIndex + 1}`;
+
+    navigator.enter(); // Enter row detail
+    const rowState = navigator.getState() as any;
+
+    assert.strictEqual(rowState.type, 'row-detail');
+    assert.strictEqual(rowState.rowIndex, expectedRowIndex, `Row index should be ${expectedRowIndex}`);
+    assert.strictEqual(rowState.row.name, expectedName, `Row name should be ${expectedName}`);
+  });
+
+  it('should handle jumping to bottom and moving up', () => {
+    navigator.init();
+    navigator.enter();
+
+    navigator.jumpToBottom();
+    let state = navigator.getState() as any;
+    assert.strictEqual(state.dataOffset + state.dataCursor, 99);
+
+    navigator.moveUp();
+    state = navigator.getState() as any;
+    assert.strictEqual(state.dataOffset + state.dataCursor, 98);
+
+    navigator.enter();
+    const rowState = navigator.getState() as any;
+    assert.strictEqual(rowState.row.name, 'Item 99');
+    assert.strictEqual(rowState.rowIndex, 98);
+  });
+
+  it('should handle jumping to top after scrolling', () => {
+    navigator.init();
+    navigator.enter();
+
+    for (let i = 0; i < 50; i++) navigator.moveDown();
+    navigator.jumpToTop();
+
+    let state = navigator.getState() as any;
+    assert.strictEqual(state.dataOffset, 0);
+    assert.strictEqual(state.dataCursor, 0);
+
+    const selectedRow = (navigator as any).getSelectedRow(state);
+    assert.strictEqual(selectedRow.name, 'Item 1');
+  });
+});

package/src/types.ts

@@ -91,10 +91,14 @@ export interface TableDetailViewState extends BaseViewState {
   totalRows: number;
   dataOffset: number;
   dataCursor: number;
+  bufferOffset: number;
   visibleRows: number;
   showSchema?: boolean;
   deleteConfirm?: DeleteConfirmationState;
   notice?: string;
+  columnWeights?: number[];
+  cachedColWidths?: number[];
+  cachedScreenWidth?: number;
 }
 
 /**
@@ -116,7 +120,11 @@ export interface RowDetailViewState extends BaseViewState {
   tableName: string;
   row: Record<string, any>;
   rowIndex: number;
+  totalRows: number;
   schema: ColumnSchema[];
+  scrollOffset: number;
+  totalLines: number;
+  visibleHeight: number;
   deleteConfirm?: DeleteConfirmationState;
   notice?: string;
 }

package/src/ui/grit/README.md

@@ -0,0 +1,58 @@
+# GRIT (Grid-TUI)
+
+GRIT is a lightweight TUI layout library built for Node.js. It focuses on a modern "OpenCode" aesthetic using solid background blocks and Unicode half-height characters for smooth transitions, rather than traditional box-drawing characters.
+
+## Design Philosophy
+
+- **Grid-based**: Everything is a grid or a box.
+- **No Lines**: Uses background colors and Unicode blocks (`▀`, `▄`) for visual separation.
+- **TrueColor**: Native support for 24-bit ANSI colors.
+- **Width-Aware**: Correctly handles CJK characters and emojis.
+
+## API
+
+### `Box`
+
+A container that handles background color, padding, and alignment.
+
+```typescript
+import { Box } from './grit/index.ts';
+
+const box = new Box({
+  width: 80,
+  background: '#1A1A1A',
+  padding: 1
+});
+
+const line = box.render("Hello World", { align: 'center' });
+```
+
+### `Transition`
+
+Creates a half-height vertical transition between two background colors.
+
+```typescript
+import { Transition } from './grit/index.ts';
+
+// Top half is #1A1A1A, bottom half is #0D0D0D
+const line = Transition.draw(80, '#1A1A1A', '#0D0D0D');
+```
+
+### `Grid`
+
+Calculates weighted column widths for tabular layouts.
+
+```typescript
+import { Grid } from './grit/index.ts';
+
+const columns = Grid.calculateWidths(100, [
+  { weight: 1 }, // Flexible
+  { weight: 2 }, // Twice as wide
+  { minWidth: 10 } // Fixed minimum
+]);
+```
+
+## Internal Utilities
+
+- `ANSI`: Low-level ANSI escape sequence generators.
+- `wrapAnsiBg`: Helper to persist background colors across ANSI resets.

package/src/ui/grit/index.test.ts

@@ -0,0 +1,67 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { Box, Transition, Grid, ANSI } from './index.ts';
+
+test('Grid.calculateWidths distributes widths correctly', () => {
+  const widths = Grid.calculateWidths(100, [
+    { weight: 1 },
+    { weight: 1 }
+  ]);
+  assert.deepEqual(widths, [50, 50]);
+
+  const weightedWidths = Grid.calculateWidths(100, [
+    { weight: 1 },
+    { weight: 3 }
+  ]);
+  assert.deepEqual(weightedWidths, [25, 75]);
+
+  const minWidths = Grid.calculateWidths(100, [
+    { weight: 1, minWidth: 40 },
+    { weight: 1 }
+  ]);
+  // Total weight 2, available 100 - 40 = 60.
+  // Col 1: 40 + (1/2 * 60) = 70
+  // Col 2: 0 + (1/2 * 60) = 30
+  assert.deepEqual(minWidths, [70, 30]);
+});
+
+test('Grid.calculateWidths caps extreme weights', () => {
+    // Avg weight = (1 + 10) / 2 = 5.5. Max weight = 22.
+    // Wait, if I have 1 and 100, avg is 50.5, max is 202. That won't cap.
+    // If I have [1, 1, 1, 10], avg is 13/4 = 3.25. Max is 13. Capped 10 is fine.
+    // If I have [1, 1, 1, 20], avg is 23/4 = 5.75. Max is 23.
+    // Let's use [1, 1, 1, 1, 1, 100]. Avg = 105/6 = 17.5. Max = 70. 100 capped to 70.
+    const configs = [
+        { weight: 1 }, { weight: 1 }, { weight: 1 }, { weight: 1 }, { weight: 1 }, { weight: 100 }
+    ];
+    const widths = Grid.calculateWidths(100, configs);
+    // Total capped weight = 1+1+1+1+1+70 = 75.
+    // Each 1 weight gets 1/75 * 100 = 1.33 -> 1
+    // 70 weight gets 70/75 * 100 = 93.33 -> 93
+    // Sum = 1*5 + 93 = 98. Last col gets remainder: 93 + 2 = 95.
+    assert.deepEqual(widths, [1, 1, 1, 1, 1, 95]);
+});
+
+test('Box renders with background and padding', () => {
+  const box = new Box({ width: 10, background: '#000000', padding: 1 });
+  const result = box.render('HI');
+
+  // ANSI.bg('#000000') + ' ' + 'HI' + ' '.repeat(10 - 1 - 2 - 1) + ' ' + ANSI.reset
+  // width 10, padding 1. Inner width 8. 'HI' is 2. Fill 6.
+  // BG + ' ' (pad) + 'HI' + '      ' (fill) + ' ' (pad) + RESET
+  const expected = `${ANSI.bg('#000000')} HI       ${ANSI.reset}`;
+  assert.strictEqual(result, expected);
+});
+
+test('Box handles alignment', () => {
+  const box = new Box({ width: 10, padding: 0 });
+
+  assert.strictEqual(box.render('HI', { align: 'right' }), '        HI');
+  assert.strictEqual(box.render('HI', { align: 'center' }), '    HI    ');
+});
+
+test('Transition.draw generates correct ANSI', () => {
+  const result = Transition.draw(5, '#FF0000', '#0000FF');
+  const expected = `${ANSI.fg('#FF0000')}${ANSI.bg('#0000FF')}▀▀▀▀▀${ANSI.reset}`;
+  assert.strictEqual(result, expected);
+});

package/src/ui/grit/index.ts

@@ -0,0 +1,101 @@
+import { ANSI, wrapAnsiBg } from './utils.ts';
+import { getVisibleWidth } from '../../utils/format.ts';
+import type { Color, Alignment, LayoutOptions, ColumnConfig } from './types.ts';
+
+export * from './types.ts';
+export * from './utils.ts';
+
+export class Box {
+  private options: LayoutOptions;
+
+  constructor(options: LayoutOptions) {
+    this.options = {
+      padding: 0,
+      ...options
+    };
+  }
+
+  render(content: string, options: { align?: Alignment; background?: Color } = {}): string {
+    const { width, background: defaultBg, padding = 0 } = this.options;
+    const bg = options.background || defaultBg || '';
+
+    const innerWidth = width - (padding * 2);
+    const contentWidth = getVisibleWidth(content);
+
+    let line = '';
+    if (bg) line += ANSI.bg(bg);
+
+    // Left padding
+    line += ' '.repeat(padding);
+
+    const fill = Math.max(0, innerWidth - contentWidth);
+    const safeContent = wrapAnsiBg(content, bg);
+
+    if (options.align === 'right') {
+      line += ' '.repeat(fill) + safeContent;
+    } else if (options.align === 'center') {
+      const leftFill = Math.floor(fill / 2);
+      const rightFill = fill - leftFill;
+      line += ' '.repeat(leftFill) + safeContent + ' '.repeat(rightFill);
+    } else {
+      line += safeContent + ' '.repeat(fill);
+    }
+
+    // Right padding
+    line += ' '.repeat(padding);
+
+    if (bg) line += ANSI.reset;
+
+    return line;
+  }
+}
+
+export class Transition {
+  static draw(width: number, topBg: Color, bottomBg: Color): string {
+    return `${ANSI.fg(topBg)}${ANSI.bg(bottomBg)}${ANSI.blockUpper.repeat(width)}${ANSI.reset}`;
+  }
+
+  static drawInverted(width: number, topBg: Color, bottomBg: Color): string {
+    return `${ANSI.fg(bottomBg)}${ANSI.bg(topBg)}${ANSI.blockLower.repeat(width)}${ANSI.reset}`;
+  }
+}
+
+export class Grid {
+  static calculateWidths(totalWidth: number, configs: ColumnConfig[]): number[] {
+    const numCols = configs.length;
+    if (numCols === 0) return [];
+
+    const minWidths = configs.map(c => c.minWidth ?? 0);
+    const weights = configs.map(c => c.weight ?? 1);
+
+    const totalMinWidth = minWidths.reduce((a, b) => a + b, 0);
+    const availableWidth = totalWidth - totalMinWidth;
+
+    if (availableWidth <= 0) {
+      // If not enough space, distribute equally based on minWidths or just evenly
+      const equalWidth = Math.floor(totalWidth / numCols);
+      return new Array(numCols).fill(equalWidth);
+    }
+
+    // Cap weights to prevent extreme ratios (max 4x average)
+    const avgWeight = weights.reduce((a, b) => a + b, 0) / numCols;
+    const maxWeight = avgWeight * 4;
+    const cappedWeights = weights.map(w => Math.min(w, maxWeight));
+    const totalWeight = cappedWeights.reduce((a, b) => a + b, 0);
+
+    if (totalWeight === 0) {
+        const equalWidth = Math.floor(totalWidth / numCols);
+        return new Array(numCols).fill(equalWidth);
+    }
+
+    const widths = cappedWeights.map((w, i) => minWidths[i] + Math.floor((w / totalWeight) * availableWidth));
+
+    // Distribute rounding remainder to the last column
+    const usedWidth = widths.reduce((a, b) => a + b, 0);
+    if (usedWidth < totalWidth) {
+      widths[widths.length - 1] += (totalWidth - usedWidth);
+    }
+
+    return widths;
+  }
+}

package/src/ui/grit/types.ts

@@ -0,0 +1,16 @@
+export type Color = string; // Hex color string like '#FFFFFF'
+
+export type Alignment = 'left' | 'right' | 'center';
+
+export interface LayoutOptions {
+  width: number;
+  height?: number;
+  padding?: number;
+  background?: Color;
+}
+
+export interface ColumnConfig {
+  weight?: number;
+  minWidth?: number;
+  maxWidth?: number;
+}

package/src/ui/grit/utils.ts

@@ -0,0 +1,35 @@
+export const ANSI = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  inverse: '\x1b[7m',
+  // TrueColor (24-bit) foreground
+  fg: (hex: string) => {
+    const { r, g, b } = hexToRgb(hex);
+    return `\x1b[38;2;${r};${g};${b}m`;
+  },
+  // TrueColor (24-bit) background
+  bg: (hex: string) => {
+    const { r, g, b } = hexToRgb(hex);
+    return `\x1b[48;2;${r};${g};${b}m`;
+  },
+  blockUpper: '▀',
+  blockLower: '▄',
+};
+
+function hexToRgb(hex: string) {
+  const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+  return result ? {
+    r: parseInt(result[1], 16),
+    g: parseInt(result[2], 16),
+    b: parseInt(result[3], 16)
+  } : { r: 0, g: 0, b: 0 };
+}
+
+/**
+ * Ensures background color is maintained if content contains ANSI resets.
+ */
+export function wrapAnsiBg(content: string, bg: string): string {
+  if (!bg) return content;
+  return content.replaceAll(ANSI.reset, ANSI.reset + ANSI.bg(bg));
+}