@carllee1983/dbcli 0.4.0-beta → 0.5.2-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.2-beta",
   description: "Database CLI for AI agents",
   type: "module",
   publishConfig: {
@@ -42767,6 +42837,27 @@ var package_default = {
   bin: {
     dbcli: "./dist/cli.mjs"
   },
+  license: "MIT",
+  author: "Carl Lee",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/CarlLee1983/dbcli.git"
+  },
+  homepage: "https://github.com/CarlLee1983/dbcli#readme",
+  bugs: {
+    url: "https://github.com/CarlLee1983/dbcli/issues"
+  },
+  keywords: [
+    "database",
+    "cli",
+    "ai",
+    "agent",
+    "postgresql",
+    "mysql",
+    "mariadb",
+    "permissions",
+    "blacklist"
+  ],
   engines: {
     node: ">=18.0.0",
     bun: ">=1.3.3"
@@ -42796,6 +42887,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: {
@@ -42831,7 +42923,11 @@ var messages_default = {
     connection_failed: "\u2717 Database connection failed",
     config_saved: "Configuration saved to .dbcli",
     config_exists_overwrite: "Configuration file .dbcli already exists. Overwrite? (y/n): ",
-    cancelled: "Cancelled. Configuration not changed."
+    cancelled: "Cancelled. Configuration not changed.",
+    skip_test_env_ref: "Skipping connection test in env-ref mode",
+    skip_test: "Skipping connection test (--skip-test)",
+    connection_hints: "Hints:",
+    config_exists_use_force: ".dbcli exists. Use --force option to overwrite."
   },
   schema: {
     description: "Retrieve table structure or list all tables",
@@ -42870,7 +42966,18 @@ var messages_default = {
     column_already_blacklisted: "Error: Column '{table}.{column}' is already blacklisted",
     column_not_in_blacklist: "Error: Column '{table}.{column}' is not in the blacklist",
     invalid_table_name: "Error: Invalid table name: {table}",
-    invalid_column_format: "Error: Invalid column format. Use 'table.column'"
+    invalid_column_format: "Error: Invalid column format. Use 'table.column'",
+    invalid_system: "Invalid database system: {system}",
+    invalid_permission: "Invalid permission level: {permission}",
+    invalid_port: "Invalid port: {port}",
+    require_user: "Non-interactive mode requires --user option",
+    require_name: "Non-interactive mode requires --name option",
+    env_refs_missing_options: `When using --use-env-refs, environment variable names must be specified.
+Provide options: --env-host, --env-port, --env-user, --env-password, --env-database
+Or use interactive mode: run "dbcli init --use-env-refs" without --no-interactive`,
+    env_var_not_defined: `Cannot test connection: environment variable {envKey} is not defined.
+Set {envKey} in .env or environment variables.
+Hint: run 'export {envKey}=<value>' and retry`
   },
   success: {
     inserted: "Successfully inserted {count} row(s)",
@@ -42920,6 +43027,11 @@ var messages_default = {
   },
   warnings: {
     blacklist_override_used: "Warning: Blacklist override enabled (DBCLI_OVERRIDE_BLACKLIST=true). Executing {operation} on blacklisted table '{table}'"
+  },
+  version: {
+    unsupported_warning: "{system} {version} is below minimum supported version {minVersion}. Some features may not work correctly.",
+    doctor_pass: "{system} {version} (meets >= {minVersion})",
+    doctor_warn: "{system} {version} is below supported >= {minVersion}"
   }
 };
 // resources/lang/zh-TW/messages.json
@@ -42940,7 +43052,11 @@ var messages_default2 = {
     connection_failed: "\u2717 \u8CC7\u6599\u5EAB\u9023\u63A5\u5931\u6557",
     config_saved: "\u914D\u7F6E\u5DF2\u4FDD\u5B58\u81F3 .dbcli",
     config_exists_overwrite: "\u914D\u7F6E\u6A94\u6848 .dbcli \u5DF2\u5B58\u5728\u3002\u662F\u5426\u8986\u84CB\uFF1F (y/n)\uFF1A",
-    cancelled: "\u5DF2\u53D6\u6D88\u3002\u914D\u7F6E\u672A\u66F4\u6539\u3002"
+    cancelled: "\u5DF2\u53D6\u6D88\u3002\u914D\u7F6E\u672A\u66F4\u6539\u3002",
+    skip_test_env_ref: "\u8DF3\u904E\u9023\u7DDA\u6E2C\u8A66\uFF08\u74B0\u5883\u8B8A\u6578\u53C3\u7167\u6A21\u5F0F\uFF09",
+    skip_test: "\u8DF3\u904E\u9023\u7DDA\u6E2C\u8A66\uFF08--skip-test\uFF09",
+    connection_hints: "\u63D0\u793A\uFF1A",
+    config_exists_use_force: ".dbcli \u5DF2\u5B58\u5728\u3002\u4F7F\u7528 --force \u9078\u9805\u8986\u84CB\u3002"
   },
   schema: {
     description: "\u6AA2\u7D22\u8868\u683C\u7D50\u69CB\u6216\u5217\u51FA\u6240\u6709\u8868\u683C",
@@ -42979,7 +43095,18 @@ var messages_default2 = {
     column_already_blacklisted: "\u932F\u8AA4: \u6B04\u4F4D '{table}.{column}' \u5DF2\u5728\u9ED1\u540D\u55AE\u4E2D",
     column_not_in_blacklist: "\u932F\u8AA4: \u6B04\u4F4D '{table}.{column}' \u4E0D\u5728\u9ED1\u540D\u55AE\u4E2D",
     invalid_table_name: "\u932F\u8AA4: \u7121\u6548\u7684\u8868\u683C\u540D\u7A31: {table}",
-    invalid_column_format: "\u932F\u8AA4: \u7121\u6548\u7684\u6B04\u4F4D\u683C\u5F0F\u3002\u4F7F\u7528 'table.column'"
+    invalid_column_format: "\u932F\u8AA4: \u7121\u6548\u7684\u6B04\u4F4D\u683C\u5F0F\u3002\u4F7F\u7528 'table.column'",
+    invalid_system: "\u7121\u6548\u7684\u8CC7\u6599\u5EAB\u7CFB\u7D71\uFF1A{system}",
+    invalid_permission: "\u7121\u6548\u7684\u6B0A\u9650\u7B49\u7D1A\uFF1A{permission}",
+    invalid_port: "\u7121\u6548\u7684\u57E0\u865F\uFF1A{port}",
+    require_user: "\u975E\u4E92\u52D5\u6A21\u5F0F\u9700\u8981 --user \u9078\u9805",
+    require_name: "\u975E\u4E92\u52D5\u6A21\u5F0F\u9700\u8981 --name \u9078\u9805",
+    env_refs_missing_options: `\u4F7F\u7528 --use-env-refs \u6642\uFF0C\u5FC5\u9808\u6307\u5B9A\u74B0\u5883\u8B8A\u6578\u540D\u7A31\u3002
+\u8ACB\u63D0\u4F9B\u9078\u9805\uFF1A--env-host\u3001--env-port\u3001--env-user\u3001--env-password\u3001--env-database
+\u6216\u4F7F\u7528\u4E92\u52D5\u6A21\u5F0F\uFF1A\u57F7\u884C "dbcli init --use-env-refs"\uFF08\u4E0D\u52A0 --no-interactive\uFF09`,
+    env_var_not_defined: `\u7121\u6CD5\u6E2C\u8A66\u9023\u7DDA\uFF1A\u74B0\u5883\u8B8A\u6578 {envKey} \u672A\u5B9A\u7FA9\u3002
+\u8ACB\u5728 .env \u6216\u74B0\u5883\u8B8A\u6578\u4E2D\u8A2D\u5B9A {envKey}\u3002
+\u63D0\u793A\uFF1A\u57F7\u884C 'export {envKey}=<value>' \u5F8C\u91CD\u8A66`
   },
   success: {
     inserted: "\u6210\u529F\u63D2\u5165 {count} \u5217",
@@ -43029,6 +43156,11 @@ var messages_default2 = {
   },
   warnings: {
     blacklist_override_used: "\u8B66\u544A: \u5DF2\u555F\u7528\u9ED1\u540D\u55AE\u8986\u84CB (DBCLI_OVERRIDE_BLACKLIST=true)\u3002\u57F7\u884C {operation} \u5728\u5DF2\u9ED1\u540D\u55AE\u7684\u8868\u683C '{table}' \u4E0A"
+  },
+  version: {
+    unsupported_warning: "{system} {version} \u4F4E\u65BC\u6700\u4F4E\u652F\u63F4\u7248\u672C {minVersion}\u3002\u90E8\u5206\u529F\u80FD\u53EF\u80FD\u7121\u6CD5\u6B63\u5E38\u904B\u4F5C\u3002",
+    doctor_pass: "{system} {version}\uFF08\u7B26\u5408 >= {minVersion}\uFF09",
+    doctor_warn: "{system} {version} \u4F4E\u65BC\u652F\u63F4\u7248\u672C >= {minVersion}"
   }
 };
 
@@ -43101,6 +43233,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) {
@@ -47546,6 +47719,61 @@ var Result = import_lib.default.Result;
 var TypeOverrides = import_lib.default.TypeOverrides;
 var defaults = import_lib.default.defaults;
 
+// src/utils/db-version-check.ts
+var MIN_SUPPORTED_VERSIONS = {
+  postgresql: "12.0",
+  mysql: "8.0",
+  mariadb: "10.5"
+};
+function parseVersionSegments(version) {
+  const match = version.match(/^(\d+(?:\.\d+)*)/);
+  if (!match)
+    return [];
+  return match[1].split(".").map(Number);
+}
+function isMariaDBVersion(versionString) {
+  return /mariadb/i.test(versionString);
+}
+function extractMariaDBVersion(versionString) {
+  const match = versionString.match(/(\d+\.\d+\.\d+)-MariaDB/i);
+  if (match)
+    return match[1];
+  const prefixMatch = versionString.match(/^5\.5\.5-(\d+\.\d+\.\d+)/);
+  if (prefixMatch)
+    return prefixMatch[1];
+  return versionString;
+}
+function compareVersions(a, b) {
+  const segA = parseVersionSegments(a);
+  const segB = parseVersionSegments(b);
+  const len = Math.max(segA.length, segB.length);
+  for (let i = 0;i < len; i++) {
+    const diff = (segA[i] ?? 0) - (segB[i] ?? 0);
+    if (diff !== 0)
+      return diff;
+  }
+  return 0;
+}
+function checkDbVersion(rawVersion, declaredSystem) {
+  const isMariaDB = isMariaDBVersion(rawVersion);
+  const system = isMariaDB ? "mariadb" : declaredSystem;
+  const serverVersion = isMariaDB ? extractMariaDBVersion(rawVersion) : rawVersion;
+  const minVersion = MIN_SUPPORTED_VERSIONS[system];
+  const supported = compareVersions(serverVersion, minVersion) >= 0;
+  return { serverVersion, system, supported, minVersion };
+}
+function warnIfUnsupported(result) {
+  if (result.supported)
+    return;
+  const message = t_vars("version.unsupported_warning", {
+    system: result.system,
+    version: result.serverVersion,
+    minVersion: result.minVersion
+  });
+  process.stderr.write(colors.warn(`\u26A0 ${message}`) + `
+`);
+}
+
 // src/adapters/postgresql-adapter.ts
 class PostgreSQLAdapter {
   pool = null;
@@ -47569,6 +47797,11 @@ class PostgreSQLAdapter {
         statement_timeout: this.options.timeout || 5000
       });
       await this.testConnection();
+      try {
+        const rawVersion = await this.getServerVersion();
+        const result = checkDbVersion(rawVersion, "postgresql");
+        warnIfUnsupported(result);
+      } catch {}
     } catch (error) {
       throw mapError(error, "postgresql", this.options);
     }
@@ -47607,6 +47840,10 @@ class PostgreSQLAdapter {
       throw mapError(error, "postgresql", this.options);
     }
   }
+  async getServerVersion() {
+    const rows = await this.execute("SHOW server_version");
+    return rows[0]?.server_version ?? "unknown";
+  }
   async listTables() {
     if (!this.pool) {
       throw new ConnectionError("UNKNOWN", "Database connection not established", ["Call connect() to establish a connection"]);
@@ -47817,6 +48054,11 @@ class MySQLAdapter {
         database: this.options.database
       });
       await this.testConnection();
+      try {
+        const rawVersion = await this.getServerVersion();
+        const result = checkDbVersion(rawVersion, this.system);
+        warnIfUnsupported(result);
+      } catch {}
     } catch (error) {
       throw mapError(error, this.system, this.options);
     }
@@ -47851,6 +48093,10 @@ class MySQLAdapter {
       throw mapError(error, this.system, this.options);
     }
   }
+  async getServerVersion() {
+    const rows = await this.execute("SELECT VERSION() as version");
+    return rows[0]?.version ?? "unknown";
+  }
   async listTables() {
     if (!this.db) {
       throw new ConnectionError("UNKNOWN", "Database connection not established", ["Call connect() to establish a connection"]);
@@ -48002,7 +48248,23 @@ class AdapterFactory {
   }
 }
 // src/commands/init.ts
-var initCommand = new Command("init").description("Initialize dbcli configuration with .env parsing and interactive prompts").option("--host <host>", "Database host").option("--port <port>", "Database port").option("--user <user>", "Database user").option("--password <password>", "Database password").option("--name <name>", "Database name").option("--system <system>", "Database system (postgresql, mysql, mariadb)").option("--permission <permission>", "Permission level (query-only, read-write, data-admin, admin)", "query-only").option("--use-env-refs", "Generate config with environment variable references (for .env)", false).option("--env-host <var>", "Environment variable name for database host (when using --use-env-refs)").option("--env-port <var>", "Environment variable name for database port (when using --use-env-refs)").option("--env-user <var>", "Environment variable name for database user (when using --use-env-refs)").option("--env-password <var>", "Environment variable name for database password (when using --use-env-refs)").option("--env-database <var>", "Environment variable name for database name (when using --use-env-refs)").option("--skip-test", "Skip database connection test").option("--no-interactive", "Non-interactive mode (requires all values via flags)").option("--force", "Skip overwrite confirmation if .dbcli exists").action(async (options) => {
+var VALID_PERMISSIONS = ["query-only", "read-write", "data-admin", "admin"];
+async function checkOverwrite(shouldPrompt, force) {
+  const configFile = Bun.file(".dbcli");
+  const fileExists = await configFile.exists();
+  if (!fileExists || force)
+    return true;
+  if (shouldPrompt) {
+    const overwrite = await promptUser.confirm(t("init.config_exists_overwrite"));
+    if (!overwrite) {
+      console.log(t("init.cancelled"));
+      return false;
+    }
+    return true;
+  }
+  throw new Error(t("init.config_exists_use_force"));
+}
+var initCommand = new Command("init").description("Initialize dbcli configuration with .env parsing and interactive prompts").option("--host <host>", "Database host").option("--port <port>", "Database port").option("--user <user>", "Database user").option("--password <password>", "Database password").option("--name <name>", "Database name").option("--system <system>", "Database system (postgresql, mysql, mariadb)").option("--permission <permission>", "Permission level (query-only, read-write, data-admin, admin)", "query-only").option("--use-env-refs", "Store env var references in config instead of actual values (for CI/CD or multi-env)", false).option("--env-host <var>", "Env var name for host (with --use-env-refs)").option("--env-port <var>", "Env var name for port (with --use-env-refs)").option("--env-user <var>", "Env var name for user (with --use-env-refs)").option("--env-password <var>", "Env var name for password (with --use-env-refs)").option("--env-database <var>", "Env var name for database (with --use-env-refs)").option("--skip-test", "Skip database connection test").option("--no-interactive", "Non-interactive mode (requires all values via flags)").option("--force", "Skip overwrite confirmation if .dbcli exists").action(async (options) => {
   try {
     await initCommandHandler(options);
   } catch (error) {
@@ -48036,7 +48298,7 @@ async function initCommandHandler(options) {
     ]);
   }
   if (!["postgresql", "mysql", "mariadb"].includes(system)) {
-    throw new Error(`Invalid database system: ${system}`);
+    throw new Error(t_vars("errors.invalid_system", { system }));
   }
   const defaults2 = getDefaultsForSystem(system);
   const connection = {
@@ -48058,34 +48320,25 @@ async function initCommandHandler(options) {
       database: { $env: envDatabase }
     };
     let permission2 = options.permission || "query-only";
-    if (shouldPrompt && !options.permission) {
+    if (!options.permission) {
       permission2 = await promptUser.select(t("init.prompt_permission"), [
         "query-only",
         "read-write",
+        "data-admin",
         "admin"
       ]);
     }
-    if (!["query-only", "read-write", "data-admin", "admin"].includes(permission2)) {
-      throw new Error(`Invalid permission level: ${permission2}`);
+    if (!VALID_PERMISSIONS.includes(permission2)) {
+      throw new Error(t_vars("errors.invalid_permission", { permission: permission2 }));
     }
     const newConfig2 = configModule.merge(existingConfig, {
       connection: configForWrite,
       permission: permission2
     });
-    const configFile2 = Bun.file(".dbcli");
-    const fileExists2 = await configFile2.exists();
-    if (fileExists2 && !options.force) {
-      if (shouldPrompt) {
-        const overwrite = await promptUser.confirm(t("init.config_exists_overwrite"));
-        if (!overwrite) {
-          console.log(t("init.cancelled"));
-          return;
-        }
-      } else {
-        throw new Error(".dbcli exists. Use --force option to overwrite.");
-      }
-    }
-    console.log("\u23ED\uFE0F  Skipping connection test in env-ref mode");
+    const canProceed2 = await checkOverwrite(shouldPrompt, !!options.force);
+    if (!canProceed2)
+      return;
+    console.log(`\u23ED\uFE0F  ${t("init.skip_test_env_ref")}`);
     await configModule.write(".dbcli", newConfig2);
     console.log(t("init.config_saved"));
     return;
@@ -48094,17 +48347,17 @@ async function initCommandHandler(options) {
   const portStr = options.port || (envConfig?.port ? String(envConfig.port) : null) || (shouldPrompt ? await promptUser.text(t("init.prompt_port"), String(defaults2.port || 5432)) : String(defaults2.port || 5432));
   const port = parseInt(portStr, 10);
   if (isNaN(port) || port < 1 || port > 65535) {
-    throw new Error(`Invalid port: ${portStr}`);
+    throw new Error(t_vars("errors.invalid_port", { port: portStr }));
   }
   connection.port = port;
   connection.user = options.user || envConfig?.user || (shouldPrompt ? await promptUser.text(t("init.prompt_user")) : "");
   if (!connection.user && !shouldPrompt && !options.useEnvRefs) {
-    throw new Error("Non-interactive mode requires --user option");
+    throw new Error(t("errors.require_user"));
   }
   connection.password = options.password || envConfig?.password || (shouldPrompt ? await promptUser.text(t("init.prompt_password")) : "");
   connection.database = options.name || envConfig?.database || (shouldPrompt ? await promptUser.text(t("init.prompt_name")) : "");
   if (!connection.database && !shouldPrompt && !options.useEnvRefs) {
-    throw new Error("Non-interactive mode requires --name option");
+    throw new Error(t("errors.require_name"));
   }
   let permission = options.permission || "query-only";
   if (shouldPrompt && !options.permission) {
@@ -48115,8 +48368,8 @@ async function initCommandHandler(options) {
       "admin"
     ]);
   }
-  if (!["query-only", "read-write", "data-admin", "admin"].includes(permission)) {
-    throw new Error(`Invalid permission level: ${permission}`);
+  if (!VALID_PERMISSIONS.includes(permission)) {
+    throw new Error(t_vars("errors.invalid_permission", { permission }));
   }
   configForWrite = connection;
   if (options.useEnvRefs) {
@@ -48126,9 +48379,7 @@ async function initCommandHandler(options) {
     const envPassword = options.envPassword;
     const envDatabase = options.envDatabase;
     if (!envHost || !envPort || !envUser || !envPassword || !envDatabase) {
-      throw new Error(`When using --use-env-refs, environment variable names must be specified.
-` + `Provide options: --env-host, --env-port, --env-user, --env-password, --env-database
-` + 'Or use interactive mode: run "bun dev init --use-env-refs" without --no-interactive');
+      throw new Error(t("errors.env_refs_missing_options"));
     }
     configForWrite = {
       system: connection.system,
@@ -48143,29 +48394,17 @@ async function initCommandHandler(options) {
     connection: configForWrite,
     permission
   });
-  const configFile = Bun.file(".dbcli");
-  const fileExists = await configFile.exists();
-  if (fileExists && !options.force) {
-    if (shouldPrompt) {
-      const overwrite = await promptUser.confirm(t("init.config_exists_overwrite"));
-      if (!overwrite) {
-        console.log(t("init.cancelled"));
-        return;
-      }
-    } else {
-      throw new Error(".dbcli exists. Use --force option to overwrite.");
-    }
-  }
+  const canProceed = await checkOverwrite(shouldPrompt, !!options.force);
+  if (!canProceed)
+    return;
   if (!options.skipTest && !options.useEnvRefs) {
     console.log(t("init.connection_testing"));
-    const resolveValue = (value, fieldName) => {
+    const resolveValue = (value, _fieldName) => {
       if (typeof value === "object" && value !== null && "$env" in value) {
         const envKey = value.$env;
         const envValue = process.env[envKey];
         if (!envValue) {
-          throw new Error(`Cannot test connection: environment variable ${envKey} is not defined
-` + `Set ${envKey} in .env or environment variables.
-` + `Hint: Check .env file or run 'export ${envKey}=<value>' and retry`);
+          throw new Error(t_vars("errors.env_var_not_defined", { envKey }));
         }
         return envValue;
       }
@@ -48189,7 +48428,7 @@ async function initCommandHandler(options) {
     } catch (error) {
       if (error instanceof ConnectionError) {
         console.error(t_vars("errors.connection_failed", { message: error.message }));
-        console.error("Hints:");
+        console.error(t("init.connection_hints"));
         error.hints.forEach((hint) => console.error(`  \u2022 ${hint}`));
         process.exit(1);
       }
@@ -48198,7 +48437,8 @@ async function initCommandHandler(options) {
       await adapter.disconnect();
     }
   } else {
-    console.log("\u23ED\uFE0F  Skipping connection test (--skip-test)");
+    const msgKey = options.useEnvRefs ? "init.skip_test_env_ref" : "init.skip_test";
+    console.log(`\u23ED\uFE0F  ${t(msgKey)}`);
   }
   await configModule.write(".dbcli", newConfig);
   console.log(t("init.config_saved"));
@@ -48210,7 +48450,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 +48476,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 +51064,657 @@ 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`
+    };
+  },
+  checkDatabaseVersion(versionResult) {
+    const vars = {
+      system: versionResult.system,
+      version: versionResult.serverVersion,
+      minVersion: versionResult.minVersion
+    };
+    return {
+      group: "Connection & Data",
+      label: "Database version",
+      status: versionResult.supported ? "pass" : "warn",
+      message: versionResult.supported ? t_vars("version.doctor_pass", vars) : t_vars("version.doctor_warn", vars)
+    };
+  },
+  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 rawVersion = await adapter.getServerVersion();
+          const versionResult = checkDbVersion(rawVersion, config.connection.system);
+          results.push(runDoctorChecks.checkDatabaseVersion(versionResult));
+        } catch {
+          logger.debug("Could not retrieve database version");
+        }
+        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 compareVersions2(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: compareVersions2(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: compareVersions2(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 +51774,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();
 }