dbn-cli 0.3.0 → 0.5.2

package/src/ui/screen.ts

@@ -26,13 +26,13 @@ export class Screen extends EventEmitter {
 
     // Enter alternate screen buffer
     stdout.write('\x1b[?1049h');
-    
+
     // Hide cursor
     stdout.write('\x1b[?25l');
-    
+
     // Clear screen
     stdout.write('\x1b[2J\x1b[H');
-    
+
     // Listen for terminal resize
     this.resizeHandler = () => {
       this.width = stdout.columns || 80;
@@ -40,7 +40,7 @@ export class Screen extends EventEmitter {
       this.emit('resize', { width: this.width, height: this.height } as ScreenDimensions);
     };
     process.on('SIGWINCH', this.resizeHandler);
-    
+
     this.isActive = true;
   }
 
@@ -52,10 +52,10 @@ export class Screen extends EventEmitter {
 
     // Show cursor
     stdout.write('\x1b[?25h');
-    
+
     // Exit alternate screen buffer
     stdout.write('\x1b[?1049l');
-    
+
     // Remove resize listener
     if (this.resizeHandler) {
       process.off('SIGWINCH', this.resizeHandler);

package/src/ui/theme.test.ts

@@ -0,0 +1,30 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import { THEME, UI } from '../ui/theme.ts';
+
+describe('Theme', () => {
+  describe('THEME', () => {
+    it('should have background colors', () => {
+      assert.ok(THEME.background);
+      assert.ok(THEME.surface);
+    });
+
+    it('should have brand colors', () => {
+      assert.ok(THEME.primary);
+      assert.ok(THEME.secondary);
+      assert.ok(THEME.accent);
+    });
+
+    it('should have semantic colors', () => {
+      assert.ok(THEME.success);
+      assert.ok(THEME.warning);
+      assert.ok(THEME.error);
+    });
+  });
+
+  describe('UI', () => {
+    it('should have ellipsis', () => {
+      assert.strictEqual(UI.ellipsis, '...');
+    });
+  });
+});

package/src/ui/theme.ts

@@ -1,58 +1,32 @@
+import { ANSI as GRIT_ANSI } from './grit/index.ts';
+
 /**
- * ANSI color codes and styling
+ * ANSI Escape Codes for Styling
  */
-export const COLORS = {
-  reset: '\x1b[0m',
-  bold: '\x1b[1m',
-  dim: '\x1b[2m',
-  italic: '\x1b[3m',
-  underline: '\x1b[4m',
-  inverse: '\x1b[7m',
-  
-  // Foreground colors
-  black: '\x1b[30m',
-  red: '\x1b[31m',
-  green: '\x1b[32m',
-  yellow: '\x1b[33m',
-  blue: '\x1b[34m',
-  magenta: '\x1b[35m',
-  cyan: '\x1b[36m',
-  white: '\x1b[37m',
-  gray: '\x1b[90m',
-  
-  // Background colors
-  bgBlack: '\x1b[40m',
-  bgRed: '\x1b[41m',
-  bgGreen: '\x1b[42m',
-  bgYellow: '\x1b[43m',
-  bgBlue: '\x1b[44m',
-  bgMagenta: '\x1b[45m',
-  bgCyan: '\x1b[46m',
-  bgWhite: '\x1b[47m',
-} as const;
+export const ANSI = GRIT_ANSI;
 
 /**
- * Unicode box drawing characters
+ * Modern color palette (OpenCode style)
  */
-export const BORDERS = {
-  horizontal: '─',
-  vertical: '│',
-  topLeft: '┌',
-  topRight: '┐',
-  bottomLeft: '└',
-  bottomRight: '┘',
-  leftJoin: '├',
-  rightJoin: '┤',
-  topJoin: '┬',
-  bottomJoin: '┴',
-  cross: '┼',
-} as const;
+export const THEME = {
+  background: '#0D0D0D',
+  surface: '#1A1A1A',
+  primary: '#00A0FF', // Brighter Blue
+  secondary: '#A259FF', // Brighter Purple
+  accent: '#FF3B30', // Red
+  text: '#FFFFFF',
+  textDim: '#8E8E93',
+  headerBg: '#242426',
+  footerBg: '#1C1C1E',
+  selectionBg: '#3A3A3C',
+  success: '#34C759',
+  warning: '#FF9500',
+  error: '#FF3B30',
+};
 
 /**
  * Common UI elements
  */
 export const UI = {
-  cursor: '>',
-  empty: ' ',
   ellipsis: '...',
 } as const;

package/src/utils/format.test.ts

@@ -0,0 +1,209 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import { formatNumber, truncate, pad, formatValue, getVisibleWidth, wrapText } from '../utils/format.ts';
+
+describe('Format Utils', () => {
+  describe('formatNumber', () => {
+    it('should format numbers with thousand separators', () => {
+      assert.strictEqual(formatNumber(1234), '1,234');
+      assert.strictEqual(formatNumber(1234567), '1,234,567');
+      assert.strictEqual(formatNumber(123), '123');
+      assert.strictEqual(formatNumber(0), '0');
+    });
+  });
+
+  describe('truncate', () => {
+    it('should truncate long strings', () => {
+      assert.strictEqual(truncate('Hello World', 8), 'Hello...');
+      assert.strictEqual(truncate('Hello World', 15), 'Hello World');
+      assert.strictEqual(truncate('Hello', 10), 'Hello');
+    });
+
+    it('should handle null and undefined', () => {
+      assert.strictEqual(truncate(null as any, 10), '');
+      assert.strictEqual(truncate(undefined as any, 10), '');
+    });
+
+    it('should handle empty strings', () => {
+      assert.strictEqual(truncate('', 10), '');
+    });
+
+    it('should convert non-strings', () => {
+      assert.strictEqual(truncate(123 as any, 5), '123');
+      assert.strictEqual(truncate(12345678 as any, 5), '12...');
+    });
+
+    it('should truncate CJK strings correctly by visible width', () => {
+      // 你好世界 = 4 chars, 8 visible width
+      assert.strictEqual(getVisibleWidth(truncate('你好世界', 5)), 5); // Should fit '你...' (2+3=5)
+      assert.strictEqual(getVisibleWidth(truncate('你好世界', 10)), 8); // Should not truncate
+      assert.strictEqual(getVisibleWidth(truncate('Hello你好', 8)), 8); // 'Hello...' = 8 width
+    });
+
+    it('should truncate emoji strings correctly by visible width', () => {
+      // 👋 = 2 visible width
+      assert.strictEqual(getVisibleWidth(truncate('Hello 👋', 6)), 6); // Should fit 'Hel...' = 6 width
+      assert.strictEqual(getVisibleWidth(truncate('👋👋👋', 5)), 5); // Should fit '👋...' (2+3=5)
+    });
+  });
+
+  describe('pad', () => {
+    it('should pad strings to the left by default', () => {
+      assert.strictEqual(pad('test', 10), 'test      ');
+      assert.strictEqual(pad('hello', 8), 'hello   ');
+    });
+
+    it('should pad strings to the right', () => {
+      assert.strictEqual(pad('test', 10, 'right'), '      test');
+      assert.strictEqual(pad('hello', 8, 'right'), '   hello');
+    });
+
+    it('should pad strings to the center', () => {
+      assert.strictEqual(pad('test', 10, 'center'), '   test   ');
+      assert.strictEqual(pad('hello', 9, 'center'), '  hello  ');
+    });
+
+    it('should truncate if string is longer than length', () => {
+      assert.strictEqual(getVisibleWidth(pad('hello world', 5)), 5);
+    });
+
+    it('should handle null and undefined', () => {
+      assert.strictEqual(pad(null as any, 5), '     ');
+      assert.strictEqual(pad(undefined as any, 5), '     ');
+    });
+
+    it('should pad CJK strings correctly by visible width', () => {
+      // 你好 = 2 chars, 4 visible width
+      const padded = pad('你好', 10);
+      assert.strictEqual(getVisibleWidth(padded), 10); // Should be 4 + 6 spaces = 10
+      
+      const rightPadded = pad('你好', 10, 'right');
+      assert.strictEqual(getVisibleWidth(rightPadded), 10); // Should be 6 spaces + 4 = 10
+    });
+
+    it('should truncate CJK strings correctly by visible width', () => {
+      // 你好世界 = 4 chars, 8 visible width
+      const truncated = pad('你好世界', 5);
+      assert.strictEqual(getVisibleWidth(truncated), 5); // Should fit up to 5 width
+    });
+
+    it('should pad emoji strings correctly by visible width', () => {
+      // 👋 = 2 visible width
+      const padded = pad('👋', 10);
+      assert.strictEqual(getVisibleWidth(padded), 10); // Should be 2 + 8 spaces = 10
+    });
+
+    it('should truncate emoji strings correctly by visible width', () => {
+      // 👋👋👋 = 6 visible width
+      const truncated = pad('👋👋👋', 5);
+      assert.strictEqual(getVisibleWidth(truncated), 5); // Should fit 2 emoji + 1 space = 5
+    });
+  });
+
+  describe('formatValue', () => {
+    it('should format null as NULL', () => {
+      assert.strictEqual(formatValue(null), 'NULL');
+    });
+
+    it('should format undefined as empty string', () => {
+      assert.strictEqual(formatValue(undefined), '');
+    });
+
+    it('should format booleans', () => {
+      assert.strictEqual(formatValue(true), 'true');
+      assert.strictEqual(formatValue(false), 'false');
+    });
+
+    it('should format objects as JSON', () => {
+      assert.strictEqual(formatValue({ key: 'value' }), '{"key":"value"}');
+      assert.strictEqual(formatValue([1, 2, 3]), '[1,2,3]');
+    });
+
+    it('should format strings as-is', () => {
+      assert.strictEqual(formatValue('hello'), 'hello');
+    });
+
+    it('should format numbers as strings', () => {
+      assert.strictEqual(formatValue(123), '123');
+      assert.strictEqual(formatValue(45.67), '45.67');
+    });
+
+    it('should pretty print objects when requested', () => {
+      const obj = { a: 1, b: [2, 3] };
+      const formatted = formatValue(obj, undefined, true);
+      assert.ok(formatted.includes('\n'));
+      assert.ok(formatted.includes('  "a": 1'));
+    });
+
+    it('should preserve newlines when pretty is requested', () => {
+      const str = 'line1\nline2';
+      assert.strictEqual(formatValue(str, undefined, true), str);
+    });
+  });
+
+  describe('wrapText', () => {
+    it('should wrap simple text', () => {
+      const text = 'hello world';
+      const lines = wrapText(text, 5);
+      assert.deepStrictEqual(lines, ['hello', ' worl', 'd']);
+    });
+
+    it('should handle CJK characters', () => {
+      const text = '你好世界';
+      const lines = wrapText(text, 4);
+      assert.deepStrictEqual(lines, ['你好', '世界']);
+    });
+
+    it('should handle existing newlines', () => {
+      const text = 'line1\nline2';
+      const lines = wrapText(text, 10);
+      assert.deepStrictEqual(lines, ['line1', 'line2']);
+    });
+
+    it('should handle empty lines', () => {
+      const text = 'line1\n\nline2';
+      const lines = wrapText(text, 10);
+      assert.deepStrictEqual(lines, ['line1', '', 'line2']);
+    });
+  });
+
+  describe('getVisibleWidth', () => {
+    it('should get width of plain strings', () => {
+      assert.strictEqual(getVisibleWidth('hello'), 5);
+      assert.strictEqual(getVisibleWidth('test string'), 11);
+    });
+
+    it('should ignore ANSI escape codes', () => {
+      assert.strictEqual(getVisibleWidth('\x1b[1mhello\x1b[0m'), 5);
+      assert.strictEqual(getVisibleWidth('\x1b[31mred text\x1b[0m'), 8);
+      assert.strictEqual(getVisibleWidth('\x1b[1m\x1b[31mbold red\x1b[0m\x1b[0m'), 8);
+    });
+
+    it('should handle empty strings', () => {
+      assert.strictEqual(getVisibleWidth(''), 0);
+    });
+
+    it('should count CJK characters as double-width', () => {
+      assert.strictEqual(getVisibleWidth('你好'), 4); // 2 Chinese chars = 4 width
+      assert.strictEqual(getVisibleWidth('Hello世界'), 9); // 5 + 2*2 = 9
+      assert.strictEqual(getVisibleWidth('こんにちは'), 10); // 5 Japanese chars = 10 width
+      assert.strictEqual(getVisibleWidth('안녕하세요'), 10); // 5 Korean chars = 10 width
+    });
+
+    it('should count emoji as double-width', () => {
+      assert.strictEqual(getVisibleWidth('👋'), 2); // Wave emoji = 2 width
+      assert.strictEqual(getVisibleWidth('Hello! 👋'), 9); // 7 + 2 = 9
+      assert.strictEqual(getVisibleWidth('😀😁😂'), 6); // 3 emoji = 6 width
+      assert.strictEqual(getVisibleWidth('Test 🎉 OK'), 10); // 4 + 1 + 2 + 1 + 2 = 10
+    });
+
+    it('should handle mixed content with CJK and ANSI codes', () => {
+      assert.strictEqual(getVisibleWidth('\x1b[1m你好\x1b[0m'), 4);
+      assert.strictEqual(getVisibleWidth('Test测试'), 8); // 4 + 2*2 = 8
+    });
+
+    it('should handle mixed emoji, CJK, and ASCII', () => {
+      assert.strictEqual(getVisibleWidth('Hello 你好 👋'), 13); // 5 + 1 + 4 + 1 + 2 = 13
+    });
+  });
+});

package/src/utils/format.ts

@@ -21,25 +21,41 @@ import stringWidth from 'string-width';
 
 export function truncate(str: string, maxWidth: number): string {
   if (!str) return '';
-  const s = String(str);
+  let s = String(str);
   
+  // Optimization: handle extremely large strings by pre-truncating
+  // A single visible character can't be more than 4 code points (e.g., complex emoji)
+  // and double-width characters count as 2.
+  // So taking maxWidth * 4 characters is a very safe upper bound.
+  if (s.length > maxWidth * 4) {
+    s = s.slice(0, maxWidth * 4);
+  }
+
   const currentWidth = getVisibleWidth(s);
   if (currentWidth <= maxWidth) return s;
   
-  // Need to truncate - build string character by character
-  let result = '';
-  let width = 0;
   const ellipsis = '...';
-  const ellipsisWidth = 3; // '...' is 3 single-width chars
+  const ellipsisWidth = 3;
   
-  // Use grapheme-aware widths using string-width
-  for (const ch of Array.from(s)) {
-    const charWidth = stringWidth(ch);
+  if (maxWidth <= ellipsisWidth) {
+    return ellipsis.slice(0, maxWidth);
+  }
 
-    if (width + charWidth + ellipsisWidth > maxWidth) break;
+  // Optimization: for plain ASCII strings, we can use slice directly
+  const isPlainASCII = /^[\x20-\x7E]*$/.test(s);
+  if (isPlainASCII) {
+    return s.slice(0, maxWidth - ellipsisWidth) + ellipsis;
+  }
 
-    result += ch;
-    width += charWidth;
+  // For complex strings, we still need to be careful about double-width characters
+  // but we can optimize by taking a slice that is definitely not too long
+  let result = s.slice(0, maxWidth);
+  while (getVisibleWidth(result) + ellipsisWidth > maxWidth && result.length > 0) {
+    // Remove one character (potentially a multi-byte character or emoji)
+    // Using Array.from to correctly handle surrogate pairs
+    const chars = Array.from(result);
+    chars.pop();
+    result = chars.join('');
   }
   
   return result + ellipsis;
@@ -95,19 +111,80 @@ export function pad(str: string, targetWidth: number, align: 'left' | 'right' |
 /**
  * Format a value for display (handle null, undefined, etc.)
  * @param value - Value to format
+ * @param maxLen - Maximum length hint to prevent processing large strings
+ * @param pretty - Whether to use pretty printing for objects and preserve newlines
  * @returns Formatted string
  */
-export function formatValue(value: any): string {
+export function formatValue(value: any, maxLen?: number, pretty?: boolean): string {
   if (value === null) return 'NULL';
   if (value === undefined) return '';
   if (typeof value === 'boolean') return value ? 'true' : 'false';
-  if (typeof value === 'object') return JSON.stringify(value);
+  if (typeof value === 'object') return JSON.stringify(value, null, pretty ? 2 : undefined);
   
-  // Convert to string and remove control characters (newlines, tabs, etc.)
-  const str = String(value);
+  // Convert to string
+  let str = String(value);
+
+  if (pretty) return str;
+
+  // Pre-truncate if it's way too long
+  if (maxLen !== undefined && str.length > maxLen * 4) {
+    str = str.slice(0, maxLen * 4);
+  }
+
+  // Remove control characters (newlines, tabs, etc.)
   return str.replace(/[\n\r\t\v\f]/g, ' ').replace(/\s+/g, ' ');
 }
 
+/**
+ * Wrap text into multiple lines based on visible width
+ * @param text - String to wrap
+ * @param maxWidth - Maximum visible width per line
+ * @returns Array of wrapped lines
+ */
+export function wrapText(text: string, maxWidth: number): string[] {
+  if (!text) return [''];
+  if (maxWidth <= 0) return [text];
+
+  const lines: string[] = [];
+  const sourceLines = text.split(/\r?\n/);
+
+  for (const sourceLine of sourceLines) {
+    if (!sourceLine) {
+      lines.push('');
+      continue;
+    }
+
+    let currentLine = '';
+    let currentWidth = 0;
+
+    for (const char of Array.from(sourceLine)) {
+      const charWidth = getVisibleWidth(char);
+
+      if (currentWidth + charWidth > maxWidth) {
+        if (currentLine) {
+          lines.push(currentLine);
+          currentLine = char;
+          currentWidth = charWidth;
+        } else {
+          // Single character is wider than maxWidth, forced break
+          lines.push(char);
+          currentLine = '';
+          currentWidth = 0;
+        }
+      } else {
+        currentLine += char;
+        currentWidth += charWidth;
+      }
+    }
+
+    if (currentLine) {
+      lines.push(currentLine);
+    }
+  }
+
+  return lines;
+}
+
 /**
  * Check if a character is double-width (CJK, emoji, etc.)
  * @param char - Single character or code point
@@ -125,13 +202,9 @@ function isDoubleWidth(_char: string): boolean {
  * @returns Visible width
  */
 export function getVisibleWidth(str: string): number {
+  if (!str) return 0;
   // Remove ANSI escape codes
   const cleanStr = str.replace(/\x1b\[[0-9;]*m/g, '');
   
-  let width = 0;
-  for (const ch of Array.from(cleanStr)) {
-    width += stringWidth(ch);
-  }
-  
-  return width;
+  return stringWidth(cleanStr);
 }