dbn-cli 0.2.4 → 0.4.0

package/README.md

@@ -1,4 +1,4 @@
-# dbn
+# dbn - DB Navigator
 
 A lightweight terminal SQLite browser with an ncdu-style interface.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dbn-cli",
-  "version": "0.2.4",
+  "version": "0.4.0",
   "description": "A lightweight terminal-based database browser",
   "repository": "https://github.com/amio/dbn-cli",
   "type": "module",

package/src/adapter/base.ts

@@ -1,4 +1,4 @@
-import type { TableInfo, ColumnSchema, QueryOptions } from '../types.ts';
+import type { TableInfo, ColumnSchema, QueryOptions, HealthInfo } from '../types.ts';
 
 /**
  * Base class for database adapters
@@ -39,6 +39,19 @@ export abstract class DatabaseAdapter {
    */
   abstract getRowCount(tableName: string): number;
 
+  /**
+   * Delete a single row from a table by its primary key values
+   * @param tableName - Name of the table
+   * @param keyValues - Primary key column/value mapping
+   */
+  abstract deleteRow(tableName: string, keyValues: Record<string, any>): void;
+
+  /**
+   * Get core database health info
+   * @returns Health information
+   */
+  abstract getHealthInfo(): HealthInfo;
+
   /**
    * Close the database connection
    */

package/src/adapter/sqlite.ts

@@ -1,6 +1,6 @@
 import { DatabaseSync } from 'node:sqlite';
 import { DatabaseAdapter } from './base.ts';
-import type { TableInfo, ColumnSchema, QueryOptions } from '../types.ts';
+import type { TableInfo, ColumnSchema, QueryOptions, HealthInfo } from '../types.ts';
 
 /**
  * SQLite adapter using Node.js 22+ built-in node:sqlite
@@ -98,6 +98,76 @@ export class SQLiteAdapter extends DatabaseAdapter {
     return result.count;
   }
 
+  /**
+   * Delete a single row from a table by its primary key values
+   * @param tableName - Name of the table
+   * @param keyValues - Primary key column/value mapping
+   */
+  deleteRow(tableName: string, keyValues: Record<string, any>): void {
+    if (!this.db) {
+      throw new Error('Database not connected');
+    }
+
+    const keys = Object.keys(keyValues);
+    if (keys.length === 0) {
+      throw new Error(`No primary key values provided for delete on ${tableName}`);
+    }
+
+    const conditions: string[] = [];
+    const values: any[] = [];
+
+    for (const key of keys) {
+      const value = keyValues[key];
+      if (value === null || value === undefined) {
+        conditions.push(`"${key}" IS NULL`);
+      } else {
+        conditions.push(`"${key}" = ?`);
+        values.push(value);
+      }
+    }
+
+    const whereClause = conditions.join(' AND ');
+    const stmt = this.db.prepare(`DELETE FROM "${tableName}" WHERE ${whereClause}`);
+    stmt.run(...values);
+  }
+
+  /**
+   * Get core database health info
+   */
+  getHealthInfo(): HealthInfo {
+    if (!this.db) {
+      throw new Error('Database not connected');
+    }
+
+    const singleValue = <T = string>(sql: string): T => {
+      const stmt = this.db!.prepare(sql);
+      const row = stmt.get() as Record<string, any> | undefined;
+      if (!row) return '' as T;
+      const value = Object.values(row)[0];
+      return value as T;
+    };
+
+    return {
+      sqlite_version: singleValue<string>('SELECT sqlite_version()'),
+      journal_mode: singleValue<string>('PRAGMA journal_mode'),
+      synchronous: String(singleValue<number>('PRAGMA synchronous')),
+      locking_mode: singleValue<string>('PRAGMA locking_mode'),
+      page_size: singleValue<number>('PRAGMA page_size'),
+      page_count: singleValue<number>('PRAGMA page_count'),
+      freelist_count: singleValue<number>('PRAGMA freelist_count'),
+      cache_size: singleValue<number>('PRAGMA cache_size'),
+      wal_autocheckpoint: singleValue<number>('PRAGMA wal_autocheckpoint'),
+      auto_vacuum: String(singleValue<number>('PRAGMA auto_vacuum')),
+      user_version: singleValue<number>('PRAGMA user_version'),
+      application_id: singleValue<number>('PRAGMA application_id'),
+      encoding: singleValue<string>('PRAGMA encoding'),
+      foreign_keys: String(singleValue<number>('PRAGMA foreign_keys')),
+      temp_store: String(singleValue<number>('PRAGMA temp_store')),
+      mmap_size: singleValue<number>('PRAGMA mmap_size'),
+      busy_timeout: singleValue<number>('PRAGMA busy_timeout')
+    };
+  }
+
   /**
    * Close the database connection
    */

package/src/index.ts

@@ -1,5 +1,5 @@
 import { stdin, stdout, exit } from 'node:process';
-import { existsSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 import * as readline from 'node:readline';
 import { SQLiteAdapter } from './adapter/sqlite.ts';
 import { Screen } from './ui/screen.ts';
@@ -112,6 +112,25 @@ export class DBPeek {
       return;
     }
 
+    if (key.name === 'y' && this.navigator.hasPendingDelete()) {
+      this.navigator.confirmDelete();
+      this.render();
+      return;
+    }
+
+    if (
+      this.navigator.hasPendingDelete() &&
+      (key.name === 'escape' || key.name === 'h' || key.name === 'left')
+    ) {
+      this.navigator.cancelDelete();
+      this.render();
+      return;
+    }
+
+    if (this.navigator.hasPendingDelete()) {
+      return;
+    }
+
     // Handle different keys
     switch (key.name) {
       case 'q':
@@ -161,6 +180,15 @@ export class DBPeek {
         this.render();
         break;
 
+      case 'backspace': {
+        const deleteState = this.navigator.getState();
+        if (deleteState.type === 'table-detail' || deleteState.type === 'row-detail') {
+          this.navigator.requestDelete();
+          this.render();
+        }
+        break;
+      }
+
       case 's':
         // Toggle schema view in full screen mode
         const currentState = this.navigator.getState();
@@ -172,6 +200,17 @@ export class DBPeek {
           this.render();
         }
         break;
+
+      case 'i':
+        // Toggle core health overview
+        const infoState = this.navigator.getState();
+        if (infoState.type === 'health') {
+          this.navigator.back();
+        } else if (infoState.type === 'tables') {
+          this.navigator.viewHealth();
+        }
+        this.render();
+        break;
     }
   }
 
@@ -227,14 +266,42 @@ export class DBPeek {
  * Main entry point
  */
 export function main(args: string[]): void {
-  const dbPath = args[0];
+  // Simple CLI parsing: support flags (-v/--version, -h/--help)
+  const flags = new Set(args.filter(a => a.startsWith('-')));
+  const dbPath = args.find(a => !a.startsWith('-'));
+
+  const printHelp = () => {
+    stdout.write(`Usage: dbn [options] <path-to-sqlite-db-file>\n\n`);
+    stdout.write(`Options:\n`);
+    stdout.write(`  -h, --help       Show help information\n`);
+    stdout.write(`  -v, --version    Show version\n\n`);
+    stdout.write(`Example:\n`);
+    stdout.write(`  dbn ./mydatabase.db\n`);
+  };
+
+  const printVersion = () => {
+    try {
+      const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')) as { version?: string };
+      stdout.write((pkg.version ?? 'unknown') + '\n');
+    } catch {
+      stdout.write('unknown\n');
+    }
+  };
 
+  if (flags.has('-h') || flags.has('--help')) {
+    printHelp();
+    exit(0);
+  }
+
+  if (flags.has('-v') || flags.has('--version')) {
+    printVersion();
+    exit(0);
+  }
+
+  // If no db path provided, show help by default
   if (!dbPath) {
-    console.error('Usage: dbn <path-to-sqlite-db-file>');
-    console.error('');
-    console.error('Example:');
-    console.error('  dbn ./mydatabase.db');
-    exit(1);
+    printHelp();
+    exit(0);
   }
 
   const app = new DBPeek(dbPath);

package/src/types.ts

@@ -30,6 +30,39 @@ export interface QueryOptions {
   offset?: number;
 }
 
+/**
+ * Core database health overview info
+ */
+export interface HealthInfo {
+  sqlite_version: string;
+  journal_mode: string;
+  synchronous: string;
+  locking_mode: string;
+  page_size: number;
+  page_count: number;
+  freelist_count: number;
+  cache_size: number;
+  wal_autocheckpoint: number;
+  auto_vacuum: string;
+  user_version: number;
+  application_id: number;
+  encoding: string;
+  foreign_keys: string;
+  temp_store: string;
+  mmap_size: number;
+  busy_timeout: number;
+}
+
+/**
+ * Delete confirmation state for write actions
+ */
+export interface DeleteConfirmationState {
+  tableName: string;
+  rowIndex: number;
+  keyValues: Record<string, any>;
+  step: 1 | 2;
+}
+
 /**
  * Base view state properties
  */
@@ -60,6 +93,8 @@ export interface TableDetailViewState extends BaseViewState {
   dataCursor: number;
   visibleRows: number;
   showSchema?: boolean;
+  deleteConfirm?: DeleteConfirmationState;
+  notice?: string;
 }
 
 /**
@@ -82,12 +117,22 @@ export interface RowDetailViewState extends BaseViewState {
   row: Record<string, any>;
   rowIndex: number;
   schema: ColumnSchema[];
+  deleteConfirm?: DeleteConfirmationState;
+  notice?: string;
+}
+
+/**
+ * Health overview view state
+ */
+export interface HealthViewState extends BaseViewState {
+  type: 'health';
+  info: HealthInfo;
 }
 
 /**
  * Union type for all possible view states
  */
-export type ViewState = TablesViewState | TableDetailViewState | SchemaViewState | RowDetailViewState;
+export type ViewState = TablesViewState | TableDetailViewState | SchemaViewState | RowDetailViewState | HealthViewState;
 
 /**
  * Screen dimensions

package/src/ui/navigator.ts

@@ -1,5 +1,5 @@
 import type { DatabaseAdapter } from '../adapter/base.ts';
-import type { ViewState, TablesViewState, TableDetailViewState, SchemaViewState, RowDetailViewState } from '../types.ts';
+import type { ViewState, TablesViewState, TableDetailViewState, SchemaViewState, RowDetailViewState, HealthViewState } from '../types.ts';
 
 /**
  * Navigation state manager
@@ -220,6 +220,179 @@ export class Navigator {
     }
   }
 
+  /**
+   * View core health overview
+   */
+  viewHealth(): void {
+    const state = this.currentState;
+    if (!state || state.type !== 'tables') return;
+
+    const info = this.adapter.getHealthInfo();
+    const newState: HealthViewState = {
+      type: 'health',
+      info
+    };
+
+    this.states.push(newState);
+    this.currentState = newState;
+  }
+
+  /**
+   * Request delete for the currently selected row
+   */
+  requestDelete(): void {
+    const state = this.currentState;
+    if (!state) return;
+
+    if (state.type === 'table-detail') {
+      state.deleteConfirm = undefined;
+      if (state.data.length === 0) {
+        state.notice = 'No row selected';
+        return;
+      }
+
+      const selectedRow = state.data[state.dataCursor];
+      if (!selectedRow) {
+        state.notice = 'No row selected';
+        return;
+      }
+
+      const result = this.getPrimaryKeyValues(state.schema, selectedRow);
+      if ('error' in result) {
+        state.notice = result.error;
+        return;
+      }
+
+      state.deleteConfirm = {
+        tableName: state.tableName,
+        rowIndex: state.dataOffset + state.dataCursor,
+        keyValues: result.keyValues,
+        step: 1
+      };
+      state.notice = `Delete row ${state.dataOffset + state.dataCursor + 1}? Press y`;
+    } else if (state.type === 'row-detail') {
+      state.deleteConfirm = undefined;
+      const result = this.getPrimaryKeyValues(state.schema, state.row);
+      if ('error' in result) {
+        state.notice = result.error;
+        return;
+      }
+
+      state.deleteConfirm = {
+        tableName: state.tableName,
+        rowIndex: state.rowIndex,
+        keyValues: result.keyValues,
+        step: 1
+      };
+      state.notice = `Delete row ${state.rowIndex + 1}? Press y`;
+    }
+  }
+
+  /**
+   * Confirm delete (multi-step)
+   */
+  confirmDelete(): void {
+    const state = this.currentState;
+    if (!state) return;
+
+    if (state.type === 'table-detail' && state.deleteConfirm) {
+      const confirm = state.deleteConfirm;
+
+      if (confirm.step === 1) {
+        state.deleteConfirm = { ...confirm, step: 2 };
+        state.notice = `Delete row ${confirm.rowIndex + 1}? Press y again`;
+        return;
+      }
+
+      try {
+        this.adapter.deleteRow(confirm.tableName, confirm.keyValues);
+      } catch (error) {
+        state.notice = `Delete failed: ${(error as Error).message}`;
+        state.deleteConfirm = undefined;
+        return;
+      }
+
+      state.deleteConfirm = undefined;
+      state.notice = `Row ${confirm.rowIndex + 1} deleted`;
+      state.totalRows = this.adapter.getRowCount(state.tableName);
+
+      const maxOffset = Math.max(0, state.totalRows - state.visibleRows);
+      state.dataOffset = Math.min(state.dataOffset, maxOffset);
+
+      this.reload();
+      if (state.dataCursor >= state.data.length) {
+        state.dataCursor = Math.max(0, state.data.length - 1);
+      }
+    } else if (state.type === 'row-detail' && state.deleteConfirm) {
+      const confirm = state.deleteConfirm;
+
+      if (confirm.step === 1) {
+        state.deleteConfirm = { ...confirm, step: 2 };
+        state.notice = `Delete row ${confirm.rowIndex + 1}? Press y again`;
+        return;
+      }
+
+      try {
+        this.adapter.deleteRow(confirm.tableName, confirm.keyValues);
+      } catch (error) {
+        state.notice = `Delete failed: ${(error as Error).message}`;
+        state.deleteConfirm = undefined;
+        return;
+      }
+
+      const parent = this.states[this.states.length - 2];
+      if (parent && parent.type === 'table-detail') {
+        parent.notice = `Row ${confirm.rowIndex + 1} deleted`;
+        parent.totalRows = this.adapter.getRowCount(parent.tableName);
+
+        const maxOffset = Math.max(0, parent.totalRows - parent.visibleRows);
+        parent.dataOffset = Math.min(parent.dataOffset, maxOffset);
+
+        parent.deleteConfirm = undefined;
+        this.states.pop();
+        this.currentState = parent;
+        this.reload();
+
+        if (parent.dataCursor >= parent.data.length) {
+          parent.dataCursor = Math.max(0, parent.data.length - 1);
+        }
+      } else {
+        state.notice = `Row ${confirm.rowIndex + 1} deleted`;
+        state.deleteConfirm = undefined;
+      }
+    }
+  }
+
+  /**
+   * Cancel delete confirmation
+   */
+  cancelDelete(): void {
+    const state = this.currentState;
+    if (!state) return;
+
+    if (state.type === 'table-detail' && state.deleteConfirm) {
+      state.deleteConfirm = undefined;
+      state.notice = 'Delete cancelled';
+    } else if (state.type === 'row-detail' && state.deleteConfirm) {
+      state.deleteConfirm = undefined;
+      state.notice = 'Delete cancelled';
+    }
+  }
+
+  /**
+   * Check if the current view is awaiting delete confirmation
+   */
+  hasPendingDelete(): boolean {
+    const state = this.currentState;
+    if (!state) return false;
+
+    if (state.type === 'table-detail' || state.type === 'row-detail') {
+      return Boolean(state.deleteConfirm);
+    }
+
+    return false;
+  }
+
   /**
    * Reload current view data
    */
@@ -236,6 +409,28 @@ export class Navigator {
     }
   }
 
+  private getPrimaryKeyValues(
+    schema: TableDetailViewState['schema'],
+    row: Record<string, any>
+  ): { keyValues: Record<string, any> } | { error: string } {
+    const pkColumns = schema
+      .filter(col => col.pk)
+      .sort((a, b) => a.pk - b.pk);
+    if (pkColumns.length === 0) {
+      return { error: 'Cannot delete: table has no primary key' };
+    }
+
+    const keyValues: Record<string, any> = {};
+    for (const col of pkColumns) {
+      if (!(col.name in row)) {
+        return { error: `Cannot delete: missing primary key value for ${col.name}` };
+      }
+      keyValues[col.name] = row[col.name];
+    }
+
+    return { keyValues };
+  }
+
   /**
    * Get breadcrumb path
    * @returns Breadcrumb path string

package/src/ui/renderer.ts

@@ -1,7 +1,7 @@
 import { COLORS, BORDERS, UI } from './theme.ts';
 import { formatNumber, truncate, pad, formatValue, getVisibleWidth } from '../utils/format.ts';
 import type { Screen } from './screen.ts';
-import type { ViewState, TablesViewState, TableDetailViewState, SchemaViewState, RowDetailViewState } from '../types.ts';
+import type { ViewState, TablesViewState, TableDetailViewState, SchemaViewState, RowDetailViewState, HealthViewState } from '../types.ts';
 
 /**
  * Renderer for ncdu-style TUI
@@ -49,6 +49,8 @@ export class Renderer {
       title += ` ${COLORS.dim}>${COLORS.reset} ${state.tableName} ${COLORS.dim}> schema${COLORS.reset}`;
     } else if (state.type === 'row-detail') {
       title += ` ${COLORS.dim}>${COLORS.reset} ${state.tableName} ${COLORS.dim}> row ${state.rowIndex + 1}${COLORS.reset}`;
+    } else if (state.type === 'health') {
+      title += ` ${COLORS.dim}>${COLORS.reset} health`;
     }
     
     title = `${COLORS.bold}${title}${COLORS.reset}`;
@@ -70,6 +72,8 @@ export class Renderer {
     } else if (state.type === 'row-detail') {
       const colCount = state.schema.length;
       rightInfo = `${COLORS.dim}${colCount} fields${COLORS.reset}`;
+    } else if (state.type === 'health') {
+      rightInfo = `${COLORS.dim}overview${COLORS.reset}`;
     }
     
     // Calculate spacing using visible width (accounts for CJK double-width)
@@ -122,6 +126,8 @@ export class Renderer {
       return this.buildSchemaView(state, height, width);
     } else if (state.type === 'row-detail') {
       return this.buildRowDetail(state, height, width);
+    } else if (state.type === 'health') {
+      return this.buildHealthView(state, height, width);
     }
     return [];
   }
@@ -477,20 +483,100 @@ export class Renderer {
     return lines;
   }
 
+  /**
+   * Build health overview view
+   */
+  private buildHealthView(state: HealthViewState, height: number, width: number): string[] {
+    const lines: string[] = [];
+    const { info } = state;
+
+    const title = `${COLORS.bold}Core health overview${COLORS.reset}`;
+    lines.push(pad(title, width));
+
+    const formatBool = (value: string): string => (value === '1' ? 'on' : value === '0' ? 'off' : value);
+    const formatAutoVacuum = (value: string): string => {
+      if (value === '0') return 'none';
+      if (value === '1') return 'full';
+      if (value === '2') return 'incremental';
+      return value;
+    };
+
+    const entries: Array<[string, string]> = [
+      ['SQLite version', info.sqlite_version],
+      ['Journal mode', info.journal_mode],
+      ['Synchronous', info.synchronous],
+      ['Locking mode', info.locking_mode],
+      ['Page size', formatNumber(info.page_size)],
+      ['Page count', formatNumber(info.page_count)],
+      ['Freelist pages', formatNumber(info.freelist_count)],
+      ['Cache size', formatNumber(info.cache_size)],
+      ['WAL autocheckpoint', formatNumber(info.wal_autocheckpoint)],
+      ['Auto vacuum', formatAutoVacuum(info.auto_vacuum)],
+      ['User version', String(info.user_version)],
+      ['Application id', String(info.application_id)],
+      ['Encoding', info.encoding],
+      ['Foreign keys', formatBool(info.foreign_keys)],
+      ['Temp store', info.temp_store],
+      ['Mmap size', formatNumber(info.mmap_size)],
+      ['Busy timeout', `${formatNumber(info.busy_timeout)} ms`]
+    ];
+
+    const labelWidth = Math.min(24, Math.max(...entries.map(([label]) => label.length)) + 1);
+    const contentWidth = width - labelWidth - 4;
+
+    for (const [label, value] of entries) {
+      if (lines.length >= height) break;
+      const labelText = pad(label, labelWidth, 'right');
+      const valueText = truncate(value, contentWidth);
+      const line = ` ${COLORS.cyan}${labelText}${COLORS.reset} ${COLORS.dim}:${COLORS.reset} ${valueText}`;
+      const lineWidth = getVisibleWidth(line);
+      if (lineWidth < width) {
+        lines.push(line + ' '.repeat(width - lineWidth));
+      } else {
+        const basicLine = ` ${labelText} : ${valueText}`;
+        lines.push(truncate(basicLine, width - 1));
+      }
+    }
+
+    while (lines.length < height) {
+      lines.push(' '.repeat(width));
+    }
+
+    return lines;
+  }
+
   /**
    * Build help bar (bottom line)
    */
   private buildHelpBar(state: ViewState, width: number): string {
     let help = '';
+    const notice =
+      (state.type === 'table-detail' || state.type === 'row-detail') ? state.notice : undefined;
+    const deleteStep =
+      (state.type === 'table-detail' || state.type === 'row-detail') ? state.deleteConfirm?.step : undefined;
+    const isDeleteConfirm =
+      (state.type === 'table-detail' || state.type === 'row-detail') ? Boolean(state.deleteConfirm) : false;
     
-    if (state.type === 'tables') {
-      help = ' [j/k] select  [Enter/l] open  [g/G] top/bottom  [q] quit';
+    if (notice && isDeleteConfirm) {
+      const stepLabel = deleteStep ? `Step ${deleteStep}/2` : '';
+      const actionLabel = deleteStep === 2 ? 'delete' : 'confirm';
+      help = ` ${COLORS.red}${COLORS.bold}${stepLabel ? `${stepLabel} ` : ''}${notice}${COLORS.reset}  ${COLORS.yellow}[y] ${actionLabel}${COLORS.reset}  [h/Esc] cancel`;
+      const paddedHelp = pad(help, width);
+      return paddedHelp;
+    } else if (notice) {
+      help = ` ${COLORS.yellow}${notice}${COLORS.reset}`;
+      const paddedHelp = pad(help, width);
+      return paddedHelp;
+    } else if (state.type === 'tables') {
+      help = ' [j/k] select  [Enter/l] open  [i] info  [g/G] top/bottom  [q] quit';
     } else if (state.type === 'table-detail') {
-      help = ' [j/k] scroll  [Enter/l] view row  [s] toggle schema  [h/Esc] back  [q] quit';
+      help = ' [j/k] scroll  [Enter/l] view row  [Backspace] delete  [s] toggle schema  [h/Esc] back  [q] quit';
     } else if (state.type === 'schema-view') {
       help = ' [j/k] scroll  [g/G] top/bottom  [s/h/Esc] back  [q] quit';
     } else if (state.type === 'row-detail') {
-      help = ' [h/Esc] back  [q] quit';
+      help = ' [Backspace] delete  [h/Esc] back  [q] quit';
+    } else if (state.type === 'health') {
+      help = ' [i] back  [h/Esc] back  [q] quit';
     }
     
     const paddedHelp = pad(help, width);