@carllee1983/dbcli 0.4.0-beta → 0.5.0-beta

package/dist/cli.mjs

@@ -2064,6 +2064,76 @@ var require_commander = __commonJS((exports) => {
   exports.InvalidOptionArgumentError = InvalidArgumentError;
 });
 
+// node_modules/picocolors/picocolors.js
+var require_picocolors = __commonJS((exports, module) => {
+  var p = process || {};
+  var argv = p.argv || [];
+  var env = p.env || {};
+  var isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+  var formatter = (open, close, replace = open) => (input) => {
+    let string = "" + input, index = string.indexOf(close, open.length);
+    return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+  };
+  var replaceClose = (string, close, replace, index) => {
+    let result = "", cursor = 0;
+    do {
+      result += string.substring(cursor, index) + replace;
+      cursor = index + close.length;
+      index = string.indexOf(close, cursor);
+    } while (~index);
+    return result + string.substring(cursor);
+  };
+  var createColors = (enabled = isColorSupported) => {
+    let f = enabled ? formatter : () => String;
+    return {
+      isColorSupported: enabled,
+      reset: f("\x1B[0m", "\x1B[0m"),
+      bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+      dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+      italic: f("\x1B[3m", "\x1B[23m"),
+      underline: f("\x1B[4m", "\x1B[24m"),
+      inverse: f("\x1B[7m", "\x1B[27m"),
+      hidden: f("\x1B[8m", "\x1B[28m"),
+      strikethrough: f("\x1B[9m", "\x1B[29m"),
+      black: f("\x1B[30m", "\x1B[39m"),
+      red: f("\x1B[31m", "\x1B[39m"),
+      green: f("\x1B[32m", "\x1B[39m"),
+      yellow: f("\x1B[33m", "\x1B[39m"),
+      blue: f("\x1B[34m", "\x1B[39m"),
+      magenta: f("\x1B[35m", "\x1B[39m"),
+      cyan: f("\x1B[36m", "\x1B[39m"),
+      white: f("\x1B[37m", "\x1B[39m"),
+      gray: f("\x1B[90m", "\x1B[39m"),
+      bgBlack: f("\x1B[40m", "\x1B[49m"),
+      bgRed: f("\x1B[41m", "\x1B[49m"),
+      bgGreen: f("\x1B[42m", "\x1B[49m"),
+      bgYellow: f("\x1B[43m", "\x1B[49m"),
+      bgBlue: f("\x1B[44m", "\x1B[49m"),
+      bgMagenta: f("\x1B[45m", "\x1B[49m"),
+      bgCyan: f("\x1B[46m", "\x1B[49m"),
+      bgWhite: f("\x1B[47m", "\x1B[49m"),
+      blackBright: f("\x1B[90m", "\x1B[39m"),
+      redBright: f("\x1B[91m", "\x1B[39m"),
+      greenBright: f("\x1B[92m", "\x1B[39m"),
+      yellowBright: f("\x1B[93m", "\x1B[39m"),
+      blueBright: f("\x1B[94m", "\x1B[39m"),
+      magentaBright: f("\x1B[95m", "\x1B[39m"),
+      cyanBright: f("\x1B[96m", "\x1B[39m"),
+      whiteBright: f("\x1B[97m", "\x1B[39m"),
+      bgBlackBright: f("\x1B[100m", "\x1B[49m"),
+      bgRedBright: f("\x1B[101m", "\x1B[49m"),
+      bgGreenBright: f("\x1B[102m", "\x1B[49m"),
+      bgYellowBright: f("\x1B[103m", "\x1B[49m"),
+      bgBlueBright: f("\x1B[104m", "\x1B[49m"),
+      bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
+      bgCyanBright: f("\x1B[106m", "\x1B[49m"),
+      bgWhiteBright: f("\x1B[107m", "\x1B[49m")
+    };
+  };
+  module.exports = createColors();
+  module.exports.createColors = createColors;
+});
+
 // node_modules/@inquirer/core/dist/esm/lib/key.mjs
 var isUpKey = (key) => key.name === "up" || key.name === "k" || key.ctrl && key.name === "p", isDownKey = (key) => key.name === "down" || key.name === "j" || key.ctrl && key.name === "n", isSpaceKey = (key) => key.name === "space", isBackspaceKey = (key) => key.name === "backspace", isNumberKey = (key) => "123456789".includes(key.name), isEnterKey = (key) => key.name === "enter" || key.name === "return";
 
@@ -2267,49 +2337,49 @@ var require_yoctocolors_cjs = __commonJS((exports, module) => {
       return result;
     };
   };
-  var colors = {};
-  colors.reset = format(0, 0);
-  colors.bold = format(1, 22);
-  colors.dim = format(2, 22);
-  colors.italic = format(3, 23);
-  colors.underline = format(4, 24);
-  colors.overline = format(53, 55);
-  colors.inverse = format(7, 27);
-  colors.hidden = format(8, 28);
-  colors.strikethrough = format(9, 29);
-  colors.black = format(30, 39);
-  colors.red = format(31, 39);
-  colors.green = format(32, 39);
-  colors.yellow = format(33, 39);
-  colors.blue = format(34, 39);
-  colors.magenta = format(35, 39);
-  colors.cyan = format(36, 39);
-  colors.white = format(37, 39);
-  colors.gray = format(90, 39);
-  colors.bgBlack = format(40, 49);
-  colors.bgRed = format(41, 49);
-  colors.bgGreen = format(42, 49);
-  colors.bgYellow = format(43, 49);
-  colors.bgBlue = format(44, 49);
-  colors.bgMagenta = format(45, 49);
-  colors.bgCyan = format(46, 49);
-  colors.bgWhite = format(47, 49);
-  colors.bgGray = format(100, 49);
-  colors.redBright = format(91, 39);
-  colors.greenBright = format(92, 39);
-  colors.yellowBright = format(93, 39);
-  colors.blueBright = format(94, 39);
-  colors.magentaBright = format(95, 39);
-  colors.cyanBright = format(96, 39);
-  colors.whiteBright = format(97, 39);
-  colors.bgRedBright = format(101, 49);
-  colors.bgGreenBright = format(102, 49);
-  colors.bgYellowBright = format(103, 49);
-  colors.bgBlueBright = format(104, 49);
-  colors.bgMagentaBright = format(105, 49);
-  colors.bgCyanBright = format(106, 49);
-  colors.bgWhiteBright = format(107, 49);
-  module.exports = colors;
+  var colors2 = {};
+  colors2.reset = format(0, 0);
+  colors2.bold = format(1, 22);
+  colors2.dim = format(2, 22);
+  colors2.italic = format(3, 23);
+  colors2.underline = format(4, 24);
+  colors2.overline = format(53, 55);
+  colors2.inverse = format(7, 27);
+  colors2.hidden = format(8, 28);
+  colors2.strikethrough = format(9, 29);
+  colors2.black = format(30, 39);
+  colors2.red = format(31, 39);
+  colors2.green = format(32, 39);
+  colors2.yellow = format(33, 39);
+  colors2.blue = format(34, 39);
+  colors2.magenta = format(35, 39);
+  colors2.cyan = format(36, 39);
+  colors2.white = format(37, 39);
+  colors2.gray = format(90, 39);
+  colors2.bgBlack = format(40, 49);
+  colors2.bgRed = format(41, 49);
+  colors2.bgGreen = format(42, 49);
+  colors2.bgYellow = format(43, 49);
+  colors2.bgBlue = format(44, 49);
+  colors2.bgMagenta = format(45, 49);
+  colors2.bgCyan = format(46, 49);
+  colors2.bgWhite = format(47, 49);
+  colors2.bgGray = format(100, 49);
+  colors2.redBright = format(91, 39);
+  colors2.greenBright = format(92, 39);
+  colors2.yellowBright = format(93, 39);
+  colors2.blueBright = format(94, 39);
+  colors2.magentaBright = format(95, 39);
+  colors2.cyanBright = format(96, 39);
+  colors2.whiteBright = format(97, 39);
+  colors2.bgRedBright = format(101, 49);
+  colors2.bgGreenBright = format(102, 49);
+  colors2.bgYellowBright = format(103, 49);
+  colors2.bgBlueBright = format(104, 49);
+  colors2.bgMagentaBright = format(105, 49);
+  colors2.bgCyanBright = format(106, 49);
+  colors2.bgWhiteBright = format(107, 49);
+  module.exports = colors2;
 });
 
 // node_modules/@inquirer/figures/dist/esm/index.js
@@ -41827,17 +41897,17 @@ var require_zalgo = __commonJS((exports, module) => {
 
 // node_modules/@colors/colors/lib/maps/america.js
 var require_america = __commonJS((exports, module) => {
-  module["exports"] = function(colors8) {
+  module["exports"] = function(colors9) {
     return function(letter, i, exploded) {
       if (letter === " ")
         return letter;
       switch (i % 3) {
         case 0:
-          return colors8.red(letter);
+          return colors9.red(letter);
         case 1:
-          return colors8.white(letter);
+          return colors9.white(letter);
         case 2:
-          return colors8.blue(letter);
+          return colors9.blue(letter);
       }
     };
   };
@@ -41845,22 +41915,22 @@ var require_america = __commonJS((exports, module) => {
 
 // node_modules/@colors/colors/lib/maps/zebra.js
 var require_zebra = __commonJS((exports, module) => {
-  module["exports"] = function(colors8) {
+  module["exports"] = function(colors9) {
     return function(letter, i, exploded) {
-      return i % 2 === 0 ? letter : colors8.inverse(letter);
+      return i % 2 === 0 ? letter : colors9.inverse(letter);
     };
   };
 });
 
 // node_modules/@colors/colors/lib/maps/rainbow.js
 var require_rainbow = __commonJS((exports, module) => {
-  module["exports"] = function(colors8) {
+  module["exports"] = function(colors9) {
     var rainbowColors = ["red", "yellow", "green", "blue", "magenta"];
     return function(letter, i, exploded) {
       if (letter === " ") {
         return letter;
       } else {
-        return colors8[rainbowColors[i++ % rainbowColors.length]](letter);
+        return colors9[rainbowColors[i++ % rainbowColors.length]](letter);
       }
     };
   };
@@ -41868,7 +41938,7 @@ var require_rainbow = __commonJS((exports, module) => {
 
 // node_modules/@colors/colors/lib/maps/random.js
 var require_random = __commonJS((exports, module) => {
-  module["exports"] = function(colors8) {
+  module["exports"] = function(colors9) {
     var available = [
       "underline",
       "inverse",
@@ -41889,40 +41959,40 @@ var require_random = __commonJS((exports, module) => {
       "brightMagenta"
     ];
     return function(letter, i, exploded) {
-      return letter === " " ? letter : colors8[available[Math.round(Math.random() * (available.length - 2))]](letter);
+      return letter === " " ? letter : colors9[available[Math.round(Math.random() * (available.length - 2))]](letter);
     };
   };
 });
 
 // node_modules/@colors/colors/lib/colors.js
 var require_colors = __commonJS((exports, module) => {
-  var colors8 = {};
-  module["exports"] = colors8;
-  colors8.themes = {};
+  var colors9 = {};
+  module["exports"] = colors9;
+  colors9.themes = {};
   var util3 = __require("util");
-  var ansiStyles = colors8.styles = require_styles();
+  var ansiStyles = colors9.styles = require_styles();
   var defineProps = Object.defineProperties;
   var newLineRegex = new RegExp(/[\r\n]+/g);
-  colors8.supportsColor = require_supports_colors().supportsColor;
-  if (typeof colors8.enabled === "undefined") {
-    colors8.enabled = colors8.supportsColor() !== false;
+  colors9.supportsColor = require_supports_colors().supportsColor;
+  if (typeof colors9.enabled === "undefined") {
+    colors9.enabled = colors9.supportsColor() !== false;
   }
-  colors8.enable = function() {
-    colors8.enabled = true;
+  colors9.enable = function() {
+    colors9.enabled = true;
   };
-  colors8.disable = function() {
-    colors8.enabled = false;
+  colors9.disable = function() {
+    colors9.enabled = false;
   };
-  colors8.stripColors = colors8.strip = function(str) {
+  colors9.stripColors = colors9.strip = function(str) {
     return ("" + str).replace(/\x1B\[\d+m/g, "");
   };
-  var stylize = colors8.stylize = function stylize2(str, style) {
-    if (!colors8.enabled) {
+  var stylize = colors9.stylize = function stylize2(str, style) {
+    if (!colors9.enabled) {
       return str + "";
     }
     var styleMap = ansiStyles[style];
-    if (!styleMap && style in colors8) {
-      return colors8[style](str);
+    if (!styleMap && style in colors9) {
+      return colors9[style](str);
     }
     return styleMap.open + str + styleMap.close;
   };
@@ -41954,7 +42024,7 @@ var require_colors = __commonJS((exports, module) => {
     });
     return ret;
   }();
-  var proto = defineProps(function colors9() {}, styles);
+  var proto = defineProps(function colors10() {}, styles);
   function applyStyle() {
     var args = Array.prototype.slice.call(arguments);
     var str = args.map(function(arg) {
@@ -41964,7 +42034,7 @@ var require_colors = __commonJS((exports, module) => {
         return util3.inspect(arg);
       }
     }).join(" ");
-    if (!colors8.enabled || !str) {
+    if (!colors9.enabled || !str) {
       return str;
     }
     var newLinesPresent = str.indexOf(`
@@ -41982,22 +42052,22 @@ var require_colors = __commonJS((exports, module) => {
     }
     return str;
   }
-  colors8.setTheme = function(theme) {
+  colors9.setTheme = function(theme) {
     if (typeof theme === "string") {
       console.log("colors.setTheme now only accepts an object, not a string.  " + "If you are trying to set a theme from a file, it is now your (the " + "caller's) responsibility to require the file.  The old syntax " + "looked like colors.setTheme(__dirname + " + "'/../themes/generic-logging.js'); The new syntax looks like " + "colors.setTheme(require(__dirname + " + "'/../themes/generic-logging.js'));");
       return;
     }
     for (var style in theme) {
       (function(style2) {
-        colors8[style2] = function(str) {
+        colors9[style2] = function(str) {
           if (typeof theme[style2] === "object") {
             var out = str;
             for (var i in theme[style2]) {
-              out = colors8[theme[style2][i]](out);
+              out = colors9[theme[style2][i]](out);
             }
             return out;
           }
-          return colors8[theme[style2]](str);
+          return colors9[theme[style2]](str);
         };
       })(style);
     }
@@ -42018,28 +42088,28 @@ var require_colors = __commonJS((exports, module) => {
     exploded = exploded.map(map2);
     return exploded.join("");
   };
-  colors8.trap = require_trap();
-  colors8.zalgo = require_zalgo();
-  colors8.maps = {};
-  colors8.maps.america = require_america()(colors8);
-  colors8.maps.zebra = require_zebra()(colors8);
-  colors8.maps.rainbow = require_rainbow()(colors8);
-  colors8.maps.random = require_random()(colors8);
-  for (map in colors8.maps) {
+  colors9.trap = require_trap();
+  colors9.zalgo = require_zalgo();
+  colors9.maps = {};
+  colors9.maps.america = require_america()(colors9);
+  colors9.maps.zebra = require_zebra()(colors9);
+  colors9.maps.rainbow = require_rainbow()(colors9);
+  colors9.maps.random = require_random()(colors9);
+  for (map in colors9.maps) {
     (function(map2) {
-      colors8[map2] = function(str) {
-        return sequencer(colors8.maps[map2], str);
+      colors9[map2] = function(str) {
+        return sequencer(colors9.maps[map2], str);
       };
     })(map);
   }
   var map;
-  defineProps(colors8, init());
+  defineProps(colors9, init());
 });
 
 // node_modules/@colors/colors/safe.js
 var require_safe = __commonJS((exports, module) => {
-  var colors8 = require_colors();
-  module["exports"] = colors8;
+  var colors9 = require_colors();
+  module["exports"] = colors9;
 });
 
 // node_modules/cli-table3/src/cell.js
@@ -42209,11 +42279,11 @@ var require_cell = __commonJS((exports, module) => {
     wrapWithStyleColors(styleProperty, content) {
       if (this[styleProperty] && this[styleProperty].length) {
         try {
-          let colors8 = require_safe();
+          let colors9 = require_safe();
           for (let i = this[styleProperty].length - 1;i >= 0; i--) {
-            colors8 = colors8[this[styleProperty][i]];
+            colors9 = colors9[this[styleProperty][i]];
           }
-          return colors8(content);
+          return colors9(content);
         } catch (e) {
           return content;
         }
@@ -42758,7 +42828,7 @@ var {
 // package.json
 var package_default = {
   name: "@carllee1983/dbcli",
-  version: "0.4.0-beta",
+  version: "0.5.0-beta",
   description: "Database CLI for AI agents",
   type: "module",
   publishConfig: {
@@ -42796,6 +42866,7 @@ var package_default = {
     dotenv: "^16.3.1",
     mysql2: "^3.20.0",
     pg: "^8.20.0",
+    picocolors: "^1.1.1",
     zod: "^3.22.4"
   },
   devDependencies: {
@@ -43101,6 +43172,47 @@ var messageLoader = MessageLoader.getInstance();
 var t = (key) => messageLoader.t(key);
 var t_vars = (key, vars) => messageLoader.interpolate(key, vars);
 
+// src/utils/colors.ts
+var import_picocolors = __toESM(require_picocolors(), 1);
+var colors = {
+  success: (text) => import_picocolors.default.green(text),
+  error: (text) => import_picocolors.default.red(text),
+  warn: (text) => import_picocolors.default.yellow(text),
+  info: (text) => import_picocolors.default.blue(text),
+  dim: (text) => import_picocolors.default.dim(text),
+  bold: (text) => import_picocolors.default.bold(text),
+  keyword: (text) => import_picocolors.default.blue(import_picocolors.default.bold(text))
+};
+
+// src/utils/logger.ts
+function formatArgs(args) {
+  return args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ");
+}
+function createLogger(level = 1 /* NORMAL */) {
+  const write = (minLevel, prefix, args) => {
+    if (level < minLevel)
+      return;
+    const message = `${prefix} ${formatArgs(args)}
+`;
+    process.stderr.write(message);
+  };
+  return {
+    error: (...args) => write(0 /* QUIET */, colors.error("[ERROR]"), args),
+    warn: (...args) => write(1 /* NORMAL */, colors.warn("[WARN]"), args),
+    info: (...args) => write(1 /* NORMAL */, colors.info("[INFO]"), args),
+    verbose: (...args) => write(2 /* VERBOSE */, colors.dim("[VERBOSE]"), args),
+    debug: (...args) => write(3 /* DEBUG */, colors.dim("[DEBUG]"), args),
+    level
+  };
+}
+var globalLogger = createLogger(1 /* NORMAL */);
+function setGlobalLogger(logger) {
+  globalLogger = logger;
+}
+function getLogger() {
+  return globalLogger;
+}
+
 // src/utils/errors.ts
 class EnvParseError extends Error {
   constructor(message) {
@@ -48210,7 +48322,7 @@ var Table = require_table();
 class TableFormatter {
   format(columns) {
     const table = new Table({
-      head: ["Column", "Type", "Nullable", "Default", "Key"],
+      head: ["Column", "Type", "Nullable", "Default", "Key"].map((h) => colors.bold(h)),
       style: { compact: false, "padding-left": 1, "padding-right": 1 },
       colWidths: [25, 25, 10, 25, 20]
     });
@@ -48236,7 +48348,7 @@ class TableFormatter {
 class TableListFormatter {
   format(tables) {
     const table = new Table({
-      head: ["Table", "Columns", "Rows", "Engine"],
+      head: ["Table", "Columns", "Rows", "Engine"].map((h) => colors.bold(h)),
       style: { compact: false, "padding-left": 1, "padding-right": 1 },
       colWidths: [30, 12, 15, 15]
     });
@@ -50824,8 +50936,637 @@ var statusCommand = new Command("status").description("Show current configuratio
   }
 });
 
+// src/commands/doctor.ts
+import { join as join3 } from "path";
+var SENSITIVE_PATTERNS = [
+  "password",
+  "passwd",
+  "secret",
+  "token",
+  "api_key",
+  "apikey",
+  "access_key",
+  "private_key",
+  "credential",
+  "auth_token",
+  "refresh_token",
+  "session_token",
+  "ssn",
+  "credit_card"
+];
+function compareSemver(a, b) {
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+  for (let i = 0;i < 3; i++) {
+    const diff = (pa[i] ?? 0) - (pb[i] ?? 0);
+    if (diff !== 0)
+      return diff;
+  }
+  return 0;
+}
+var runDoctorChecks = {
+  checkBunVersion(current, required) {
+    const passes = compareSemver(current, required) >= 0;
+    return {
+      group: "Environment",
+      label: "Bun version",
+      status: passes ? "pass" : "error",
+      message: passes ? `Bun v${current} (meets >= ${required})` : `Bun v${current} is below required >= ${required}`
+    };
+  },
+  async checkLatestVersion(currentVersion) {
+    try {
+      const response = await fetch("https://registry.npmjs.org/@carllee1983/dbcli/latest", { signal: AbortSignal.timeout(5000) });
+      if (!response.ok)
+        throw new Error(`HTTP ${response.status}`);
+      const data = await response.json();
+      const latest = data.version;
+      const isLatest = currentVersion === latest;
+      return {
+        group: "Environment",
+        label: "dbcli version",
+        status: isLatest ? "pass" : "warn",
+        message: isLatest ? `dbcli v${currentVersion} (latest)` : `dbcli v${currentVersion} (latest: ${latest})`
+      };
+    } catch {
+      return {
+        group: "Environment",
+        label: "dbcli version",
+        status: "pass",
+        message: `dbcli v${currentVersion} (version check skipped)`
+      };
+    }
+  },
+  async checkConfigExists(configPath, existsFn) {
+    const exists = existsFn ? await existsFn(configPath) : await Bun.file(configPath).exists() || await Bun.file(join3(configPath, "config.json")).exists();
+    return {
+      group: "Configuration",
+      label: "Config exists",
+      status: exists ? "pass" : "error",
+      message: exists ? `Config found: ${configPath}` : `No config found at ${configPath}. Run "dbcli init" first.`
+    };
+  },
+  checkBlacklistCompleteness(tableColumns, blacklistedColumns) {
+    const unprotected = [];
+    for (const [table, columns] of tableColumns) {
+      const blacklisted = blacklistedColumns.get(table) ?? new Set;
+      for (const col of columns) {
+        const colLower = col.toLowerCase();
+        const isSensitive = SENSITIVE_PATTERNS.some((p) => colLower.includes(p));
+        if (isSensitive && !blacklisted.has(col)) {
+          unprotected.push(`${table}.${col}`);
+        }
+      }
+    }
+    if (unprotected.length === 0) {
+      return {
+        group: "Configuration",
+        label: "Blacklist completeness",
+        status: "pass",
+        message: "All detected sensitive columns are protected"
+      };
+    }
+    return {
+      group: "Configuration",
+      label: "Blacklist completeness",
+      status: "warn",
+      message: `Consider protecting: ${unprotected.join(", ")}`
+    };
+  },
+  checkSchemaCacheFreshness(lastUpdated) {
+    if (!lastUpdated) {
+      return {
+        group: "Connection & Data",
+        label: "Schema cache",
+        status: "warn",
+        message: 'No schema cache found \u2014 run "dbcli schema --refresh"'
+      };
+    }
+    const ageMs = Date.now() - new Date(lastUpdated).getTime();
+    const ageDays = Math.floor(ageMs / (24 * 60 * 60 * 1000));
+    if (ageDays > 7) {
+      return {
+        group: "Connection & Data",
+        label: "Schema cache",
+        status: "warn",
+        message: `Schema cache is ${ageDays} days old \u2014 run "dbcli schema --refresh"`
+      };
+    }
+    return {
+      group: "Connection & Data",
+      label: "Schema cache",
+      status: "pass",
+      message: `Schema cache is ${ageDays} day(s) old`
+    };
+  },
+  checkLargeTables(tables) {
+    const large = tables.filter((t7) => (t7.estimatedRowCount ?? 0) > 1e6);
+    if (large.length === 0) {
+      return {
+        group: "Connection & Data",
+        label: "Large tables",
+        status: "pass",
+        message: "No tables exceed 1M rows"
+      };
+    }
+    const list = large.map((t7) => `${t7.name} (${((t7.estimatedRowCount ?? 0) / 1e6).toFixed(1)}M rows)`).join(", ");
+    return {
+      group: "Connection & Data",
+      label: "Large tables",
+      status: "warn",
+      message: `Large tables: ${list}`
+    };
+  },
+  formatTextOutput(results, version) {
+    const lines2 = [`dbcli doctor v${version}`, ""];
+    const groups = ["Environment", "Configuration", "Connection & Data"];
+    for (const group of groups) {
+      const groupResults = results.filter((r) => r.group === group);
+      if (groupResults.length === 0)
+        continue;
+      lines2.push(group);
+      for (const r of groupResults) {
+        const icon = r.status === "pass" ? colors.success("\u2713") : r.status === "warn" ? colors.warn("\u26A0") : colors.error("\u2717");
+        lines2.push(`  ${icon} ${r.message}`);
+      }
+      lines2.push("");
+    }
+    const passed = results.filter((r) => r.status === "pass").length;
+    const warnings = results.filter((r) => r.status === "warn").length;
+    const errors3 = results.filter((r) => r.status === "error").length;
+    lines2.push(`Summary: ${passed} passed, ${warnings} warning(s), ${errors3} error(s)`);
+    return lines2.join(`
+`);
+  }
+};
+var doctorCommand = new Command("doctor").description("Run diagnostic checks on dbcli configuration, environment, and connection").option("--format <type>", "Output format: text, json", "text").action(async (options) => {
+  const logger = getLogger();
+  const results = [];
+  const configPath = doctorCommand.parent?.opts().config ?? ".dbcli";
+  const bunVersion = process.versions.bun ?? "unknown";
+  const requiredBun = package_default.engines?.bun?.replace(">=", "") ?? "1.3.3";
+  results.push(runDoctorChecks.checkBunVersion(bunVersion, requiredBun));
+  results.push(await runDoctorChecks.checkLatestVersion(package_default.version));
+  const configExists = await runDoctorChecks.checkConfigExists(configPath);
+  results.push(configExists);
+  if (configExists.status !== "error") {
+    try {
+      const config = await configModule.read(configPath);
+      results.push({
+        group: "Configuration",
+        label: "Config valid",
+        status: "pass",
+        message: "Config valid"
+      });
+      results.push({
+        group: "Configuration",
+        label: "Permission",
+        status: "pass",
+        message: `Permission: ${config.permission}`
+      });
+      const blacklistedColumns = new Map;
+      if (config.blacklist?.columns) {
+        for (const [table, cols] of Object.entries(config.blacklist.columns)) {
+          blacklistedColumns.set(table, new Set(cols));
+        }
+      }
+      try {
+        const adapter = AdapterFactory.createAdapter(config.connection);
+        await adapter.connect();
+        results.push({
+          group: "Connection & Data",
+          label: "Connection",
+          status: "pass",
+          message: `Connected to ${config.connection.system} ${config.connection.database}@${config.connection.host}:${config.connection.port}`
+        });
+        try {
+          const tables = await adapter.listTables();
+          const tableColumns = new Map;
+          for (const t7 of tables) {
+            tableColumns.set(t7.name, t7.columns.map((c) => c.name));
+          }
+          results.push(runDoctorChecks.checkBlacklistCompleteness(tableColumns, blacklistedColumns));
+          results.push(runDoctorChecks.checkLargeTables(tables));
+        } catch {
+          logger.debug("Could not list tables for blacklist/large table check");
+        }
+        try {
+          const indexPath = join3(configPath, "schemas", "index.json");
+          const indexFile = Bun.file(indexPath);
+          if (await indexFile.exists()) {
+            const indexContent = await indexFile.text();
+            const index = JSON.parse(indexContent);
+            results.push(runDoctorChecks.checkSchemaCacheFreshness(index.updatedAt ?? null));
+          } else {
+            results.push(runDoctorChecks.checkSchemaCacheFreshness(null));
+          }
+        } catch {
+          results.push(runDoctorChecks.checkSchemaCacheFreshness(null));
+        }
+        await adapter.disconnect();
+      } catch (error) {
+        results.push({
+          group: "Connection & Data",
+          label: "Connection",
+          status: "error",
+          message: `Connection failed: ${error.message}`
+        });
+      }
+    } catch (error) {
+      results.push({
+        group: "Configuration",
+        label: "Config valid",
+        status: "error",
+        message: `Config invalid: ${error.message}`
+      });
+    }
+  }
+  const hasError = results.some((r) => r.status === "error");
+  if (options.format === "json") {
+    console.log(JSON.stringify({ results, hasError }, null, 2));
+  } else {
+    console.log(runDoctorChecks.formatTextOutput(results, package_default.version));
+  }
+  if (hasError) {
+    process.exit(1);
+  }
+});
+
+// src/commands/completion.ts
+import { join as join4 } from "path";
+import { homedir as homedir2 } from "os";
+function extractCommands(program2) {
+  return program2.commands.map((cmd) => ({
+    name: cmd.name(),
+    options: cmd.options.map((o) => o.long ?? o.short ?? "").filter(Boolean)
+  }));
+}
+function extractGlobalOptions(program2) {
+  return program2.options.map((o) => o.long ?? o.short ?? "").filter(Boolean);
+}
+function generateBashCompletion(commands, globalOptions) {
+  const cmdNames = commands.map((c) => c.name).join(" ");
+  const globalOpts = globalOptions.join(" ");
+  const caseEntries = commands.map((c) => `    ${c.name})
+      COMPREPLY=( $(compgen -W "${c.options.join(" ")}" -- "\${cur}") )
+      ;;`).join(`
+`);
+  return `#!/bin/bash
+# dbcli bash completion \u2014 auto-generated, do not edit
+_dbcli_completions() {
+  local cur prev commands
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  prev="\${COMP_WORDS[COMP_CWORD-1]}"
+  commands="${cmdNames}"
+
+  if [[ \${COMP_CWORD} -eq 1 ]]; then
+    COMPREPLY=( $(compgen -W "\${commands} ${globalOpts}" -- "\${cur}") )
+    return 0
+  fi
+
+  case "\${COMP_WORDS[1]}" in
+${caseEntries}
+    *)
+      COMPREPLY=( $(compgen -W "${globalOpts}" -- "\${cur}") )
+      ;;
+  esac
+}
+complete -F _dbcli_completions dbcli
+`;
+}
+function generateZshCompletion(commands, globalOptions) {
+  const cmdLines = commands.map((c) => `    '${c.name}:${c.name} command'`).join(`
+`);
+  const subcmdCases = commands.map((c) => {
+    const opts = c.options.map((o) => `'${o}[${o}]'`).join(" ");
+    return `  ${c.name})
+    _arguments ${opts}
+    ;;`;
+  }).join(`
+`);
+  const globalOpts = globalOptions.map((o) => `'${o}[${o}]'`).join(" ");
+  return `#compdef dbcli
+# dbcli zsh completion \u2014 auto-generated, do not edit
+_dbcli() {
+  local -a commands
+  commands=(
+${cmdLines}
+  )
+
+  _arguments -C \\
+    ${globalOpts} \\
+    '1:command:->cmd' \\
+    '*::arg:->args'
+
+  case "$state" in
+  cmd)
+    _describe 'command' commands
+    ;;
+  args)
+    case "$words[1]" in
+${subcmdCases}
+    esac
+    ;;
+  esac
+}
+_dbcli
+`;
+}
+function generateFishCompletion(commands, globalOptions) {
+  const lines2 = [
+    "# dbcli fish completion \u2014 auto-generated, do not edit",
+    ""
+  ];
+  for (const opt of globalOptions) {
+    const longName = opt.replace(/^--/, "");
+    lines2.push(`complete -c dbcli -n '__fish_use_subcommand' -l ${longName} -d '${opt}'`);
+  }
+  for (const cmd of commands) {
+    lines2.push(`complete -c dbcli -n '__fish_use_subcommand' -a ${cmd.name} -d '${cmd.name} command'`);
+  }
+  for (const cmd of commands) {
+    for (const opt of cmd.options) {
+      const longName = opt.replace(/^--/, "");
+      lines2.push(`complete -c dbcli -n '__fish_seen_subcommand_from ${cmd.name}' -l ${longName} -d '${opt}'`);
+    }
+  }
+  return lines2.join(`
+`) + `
+`;
+}
+function getInstallPath2(shell) {
+  const home = homedir2();
+  switch (shell) {
+    case "bash":
+      return join4(home, ".bashrc");
+    case "zsh":
+      return join4(home, ".zshrc");
+    case "fish":
+      return join4(home, ".config", "fish", "completions", "dbcli.fish");
+    default:
+      throw new Error(`Unsupported shell: ${shell}. Supported: bash, zsh, fish`);
+  }
+}
+function detectShell() {
+  const shellEnv = process.env.SHELL ?? "";
+  if (shellEnv.includes("zsh"))
+    return "zsh";
+  if (shellEnv.includes("bash"))
+    return "bash";
+  if (shellEnv.includes("fish"))
+    return "fish";
+  return "bash";
+}
+var MARKER_START = "# >>> dbcli completion >>>";
+var MARKER_END = "# <<< dbcli completion <<<";
+async function installCompletion(shell, script) {
+  const targetPath = getInstallPath2(shell);
+  if (shell === "fish") {
+    const dir = join4(homedir2(), ".config", "fish", "completions");
+    await Bun.$`mkdir -p ${dir}`.quiet();
+    await Bun.file(targetPath).write(script);
+    console.log(colors.success(`\u2713 Fish completion installed to ${targetPath}`));
+    return;
+  }
+  const file = Bun.file(targetPath);
+  let content = "";
+  if (await file.exists()) {
+    content = await file.text();
+  }
+  const markerRegex = new RegExp(`${MARKER_START}[\\s\\S]*?${MARKER_END}\\n?`, "g");
+  content = content.replace(markerRegex, "");
+  const block = `
+${MARKER_START}
+eval "$(dbcli completion ${shell})"
+${MARKER_END}
+`;
+  content = content.trimEnd() + `
+` + block;
+  await Bun.file(targetPath).write(content);
+  console.log(colors.success(`\u2713 Completion installed to ${targetPath}`));
+  console.log(colors.info(`  Run: source ${targetPath}`));
+}
+var completionCommand = new Command("completion").description("Generate shell completion scripts (bash, zsh, fish)").argument("[shell]", "Shell type: bash, zsh, fish").option("--install [shell]", "Auto-install completion to shell rc file").action(async (shellArg, options) => {
+  const parentProgram = completionCommand.parent;
+  if (!parentProgram) {
+    console.error(colors.error("Error: completion command must be registered to a program"));
+    process.exit(1);
+  }
+  const commands = extractCommands(parentProgram);
+  const globalOptions = extractGlobalOptions(parentProgram);
+  if (options.install !== undefined) {
+    const shell2 = typeof options.install === "string" ? options.install : shellArg ?? detectShell();
+    const generators2 = {
+      bash: generateBashCompletion,
+      zsh: generateZshCompletion,
+      fish: generateFishCompletion
+    };
+    const generate2 = generators2[shell2];
+    if (!generate2) {
+      console.error(colors.error(`Unsupported shell: ${shell2}. Supported: bash, zsh, fish`));
+      process.exit(1);
+    }
+    const script = generate2(commands, globalOptions);
+    await installCompletion(shell2, script);
+    return;
+  }
+  const shell = shellArg ?? detectShell();
+  const generators = {
+    bash: generateBashCompletion,
+    zsh: generateZshCompletion,
+    fish: generateFishCompletion
+  };
+  const generate = generators[shell];
+  if (!generate) {
+    console.error(colors.error(`Unsupported shell: ${shell}. Supported: bash, zsh, fish`));
+    process.exit(1);
+  }
+  process.stdout.write(generate(commands, globalOptions));
+});
+
+// src/utils/version-check.ts
+var NPM_REGISTRY_URL = "https://registry.npmjs.org/@carllee1983/dbcli/latest";
+var STALE_THRESHOLD_MS = 24 * 60 * 60 * 1000;
+var FETCH_TIMEOUT_MS = 3000;
+function compareVersions(a, b) {
+  const stripSuffix = (v) => v.replace(/-.*$/, "");
+  const pa = stripSuffix(a).split(".").map(Number);
+  const pb = stripSuffix(b).split(".").map(Number);
+  for (let i = 0;i < 3; i++) {
+    const diff = (pa[i] ?? 0) - (pb[i] ?? 0);
+    if (diff !== 0)
+      return diff;
+  }
+  if (a === b)
+    return 0;
+  const aHasSuffix = a.includes("-");
+  const bHasSuffix = b.includes("-");
+  if (!aHasSuffix && bHasSuffix)
+    return 1;
+  if (aHasSuffix && !bHasSuffix)
+    return -1;
+  return a.localeCompare(b);
+}
+function isStale(checkedAt) {
+  const checked = new Date(checkedAt).getTime();
+  if (isNaN(checked))
+    return true;
+  return Date.now() - checked >= STALE_THRESHOLD_MS;
+}
+async function fetchLatestVersion() {
+  try {
+    const response = await fetch(NPM_REGISTRY_URL, {
+      signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
+    });
+    if (!response.ok)
+      return null;
+    const data = await response.json();
+    return data.version ?? null;
+  } catch {
+    return null;
+  }
+}
+async function checkForUpdate(currentVersion, cachePath, existingCache) {
+  let cache = existingCache ?? null;
+  if (cache === undefined && cachePath) {
+    try {
+      const cacheFile = Bun.file(`${cachePath}/version-check.json`);
+      if (await cacheFile.exists()) {
+        cache = await cacheFile.json();
+      }
+    } catch {
+      cache = null;
+    }
+  }
+  if (cache && !isStale(cache.checkedAt)) {
+    return {
+      hasUpdate: compareVersions(cache.latestVersion, currentVersion) > 0,
+      latestVersion: cache.latestVersion
+    };
+  }
+  const latestVersion = await fetchLatestVersion();
+  if (!latestVersion)
+    return null;
+  if (cachePath) {
+    try {
+      const newCache = {
+        latestVersion,
+        checkedAt: new Date().toISOString()
+      };
+      await Bun.write(`${cachePath}/version-check.json`, JSON.stringify(newCache, null, 2));
+    } catch {}
+  }
+  return {
+    hasUpdate: compareVersions(latestVersion, currentVersion) > 0,
+    latestVersion
+  };
+}
+
+// src/commands/upgrade.ts
+function formatAlreadyUpToDate(version) {
+  return colors.success(`\u2713 Already up to date (v${version})`);
+}
+function formatUpgradeMessage(currentVersion, latestVersion) {
+  return [
+    colors.info(`  Current version : v${currentVersion}`),
+    colors.success(`  Latest version  : v${latestVersion}`)
+  ].join(`
+`);
+}
+function formatUpdateHint(latestVersion) {
+  return colors.warn(`[INFO] dbcli v${latestVersion} available. Run "dbcli upgrade" to upgrade.`);
+}
+var upgradeCommand = new Command("upgrade").description("Check for updates and upgrade dbcli to the latest version").option("--check", "Only check for updates, do not upgrade").action(async (options) => {
+  const configPath = upgradeCommand.parent?.opts().config ?? ".dbcli";
+  const currentVersion = package_default.version;
+  console.log(colors.bold("Checking for updates..."));
+  let cachePath = null;
+  try {
+    const file = Bun.file(configPath);
+    const isDir = !configPath.includes(".") || await file.exists() === false;
+    if (isDir) {
+      cachePath = configPath;
+    }
+  } catch {
+    cachePath = null;
+  }
+  const result = await checkForUpdate(currentVersion, cachePath);
+  if (!result) {
+    console.error(colors.warn("\u26A0 Could not check for updates (network error or registry unavailable)"));
+    process.exit(0);
+  }
+  if (!result.hasUpdate) {
+    console.log(formatAlreadyUpToDate(currentVersion));
+    process.exit(0);
+  }
+  console.log(colors.warn(`
+  New version available: v${result.latestVersion}`));
+  console.log(formatUpgradeMessage(currentVersion, result.latestVersion));
+  console.log();
+  if (options.check) {
+    console.log(colors.dim('  Run "dbcli upgrade" to install the update.'));
+    process.exit(0);
+  }
+  console.log(colors.bold("Upgrading..."));
+  console.log(colors.dim(`  bun add -g @carllee1983/dbcli@latest`));
+  console.log();
+  const proc = Bun.$`bun add -g @carllee1983/dbcli@latest`.nothrow();
+  const result2 = await proc;
+  if (result2.exitCode === 0) {
+    console.log(colors.success(`
+\u2713 Successfully upgraded to v${result.latestVersion}`));
+  } else {
+    console.error(colors.error(`
+\u2717 Upgrade failed. Try running manually:`));
+    console.error(colors.dim("  bun add -g @carllee1983/dbcli@latest"));
+    process.exit(1);
+  }
+});
+
 // src/cli.ts
-var program2 = new Command().name("dbcli").description("Database CLI for AI agents").version(package_default.version).option("--config <path>", "Path to .dbcli config file", ".dbcli");
+import { join as join5 } from "path";
+var _bgVersionCheckResult;
+var program2 = new Command().name("dbcli").description("Database CLI for AI agents").version(package_default.version).option("--no-color", "Disable colored output").option("-v, --verbose", "Increase verbosity (-v verbose, -vv debug)", (_, prev) => prev + 1, 0).option("-q, --quiet", "Suppress non-essential output").option("--config <path>", "Path to .dbcli config file", ".dbcli");
+program2.hook("preAction", (thisCommand, actionCommand) => {
+  const opts = thisCommand.opts();
+  if (opts.color === false) {
+    process.env.NO_COLOR = "1";
+  }
+  let level = 1 /* NORMAL */;
+  if (opts.quiet) {
+    level = 0 /* QUIET */;
+  } else if (opts.verbose >= 2) {
+    level = 3 /* DEBUG */;
+  } else if (opts.verbose >= 1) {
+    level = 2 /* VERBOSE */;
+  }
+  setGlobalLogger(createLogger(level));
+  const isUpgradeCommand = actionCommand.name() === "upgrade";
+  if (!opts.quiet && !isUpgradeCommand) {
+    const configPath = opts.config ?? ".dbcli";
+    (async () => {
+      try {
+        let cache = null;
+        try {
+          const cacheFile = Bun.file(join5(configPath, "version-check.json"));
+          if (await cacheFile.exists()) {
+            cache = await cacheFile.json();
+          }
+        } catch {}
+        const result = await checkForUpdate(package_default.version, configPath, cache);
+        _bgVersionCheckResult = result;
+      } catch {
+        _bgVersionCheckResult = null;
+      }
+    })();
+  }
+});
+program2.hook("postAction", () => {
+  if (_bgVersionCheckResult?.hasUpdate) {
+    process.stderr.write(formatUpdateHint(_bgVersionCheckResult.latestVersion) + `
+`);
+  }
+});
 program2.addCommand(initCommand);
 program2.addCommand(listCommand);
 program2.addCommand(schemaCommand);
@@ -50885,6 +51626,9 @@ program2.addCommand(blacklistCommand);
 program2.addCommand(checkCommand);
 program2.addCommand(diffCommand);
 program2.addCommand(statusCommand);
+program2.addCommand(doctorCommand);
+program2.addCommand(completionCommand);
+program2.addCommand(upgradeCommand);
 if (!process.argv.slice(2).length) {
   program2.outputHelp();
 }