@carllee1983/dbcli 0.3.2-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.3.2-beta",
+  version: "0.5.0-beta",
   description: "Database CLI for AI agents",
   type: "module",
   publishConfig: {
@@ -42773,6 +42843,7 @@ var package_default = {
   },
   files: [
     "dist/",
+    "assets/",
     "README.md",
     "CHANGELOG.md",
     "LICENSE"
@@ -42795,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: {
@@ -42823,7 +42895,7 @@ var messages_default = {
     prompt_user: "Database user: ",
     prompt_password: "Database password: ",
     prompt_name: "Database name: ",
-    prompt_permission: "Permission level (query-only, read-write, admin): ",
+    prompt_permission: "Permission level (query-only, read-write, data-admin, admin): ",
     env_parse_note: "Note: Unable to parse .env configuration, using interactive prompts",
     connection_testing: "Testing database connection...",
     connection_success: "\u2713 Database connection successful",
@@ -42892,7 +42964,7 @@ var messages_default = {
     description: "Delete data from a table",
     prompt_where: "Enter WHERE clause (e.g., id=1): ",
     confirm: "Delete rows from {table}? (y/n): ",
-    admin_only: "Delete command requires admin permission"
+    admin_only: "Delete command requires data-admin or admin permission"
   },
   export: {
     description: "Export query results",
@@ -42932,7 +43004,7 @@ var messages_default2 = {
     prompt_user: "\u8CC7\u6599\u5EAB\u4F7F\u7528\u8005\uFF1A",
     prompt_password: "\u8CC7\u6599\u5EAB\u5BC6\u78BC\uFF1A",
     prompt_name: "\u8CC7\u6599\u5EAB\u540D\u7A31\uFF1A",
-    prompt_permission: "\u6B0A\u9650\u7B49\u7D1A\uFF08query-only, read-write, admin\uFF09\uFF1A",
+    prompt_permission: "\u6B0A\u9650\u7B49\u7D1A\uFF08query-only, read-write, data-admin, admin\uFF09\uFF1A",
     env_parse_note: "\u63D0\u793A\uFF1A\u7121\u6CD5\u89E3\u6790 .env \u914D\u7F6E\uFF0C\u4F7F\u7528\u4E92\u52D5\u5F0F\u63D0\u793A",
     connection_testing: "\u6B63\u5728\u6E2C\u8A66\u8CC7\u6599\u5EAB\u9023\u63A5...",
     connection_success: "\u2713 \u8CC7\u6599\u5EAB\u9023\u63A5\u6210\u529F",
@@ -43001,7 +43073,7 @@ var messages_default2 = {
     description: "\u522A\u9664\u8868\u683C\u4E2D\u7684\u8CC7\u6599",
     prompt_where: "\u8F38\u5165 WHERE \u5B50\u53E5 (\u4F8B\u5982\uFF1Aid=1)\uFF1A",
     confirm: "\u522A\u9664 {table} \u4E2D\u7684\u5217\uFF1F (y/n)\uFF1A",
-    admin_only: "\u522A\u9664\u547D\u4EE4\u9700\u8981\u7BA1\u7406\u54E1\u6B0A\u9650"
+    admin_only: "\u522A\u9664\u547D\u4EE4\u9700\u8981 data-admin \u6216 admin \u6B0A\u9650"
   },
   export: {
     description: "\u532F\u51FA\u67E5\u8A62\u7D50\u679C",
@@ -43100,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) {
@@ -43156,7 +43269,7 @@ function parseConnectionUrl(url) {
     } else if (protocol === "mariadb") {
       system = "mariadb";
     } else {
-      throw new Error(`\u4E0D\u652F\u63F4\u7684\u5354\u8B70: ${protocol}`);
+      throw new Error(`Unsupported protocol: ${protocol}`);
     }
     const host = parsed.hostname || "localhost";
     const port = parsed.port !== "" ? parseInt(parsed.port, 10) : getDefaultsForSystem(system).port || 5432;
@@ -43165,7 +43278,7 @@ function parseConnectionUrl(url) {
     const database = parsed.pathname.slice(1);
     return { system, host, port, user, password, database };
   } catch (error) {
-    throw new EnvParseError(`\u7121\u6CD5\u89E3\u6790 DATABASE_URL: ${error instanceof Error ? error.message : String(error)}`);
+    throw new EnvParseError(`Failed to parse DATABASE_URL: ${error instanceof Error ? error.message : String(error)}`);
   }
 }
 function parseEnvDatabase(env) {
@@ -43177,15 +43290,15 @@ function parseEnvDatabase(env) {
     const user = env.DB_USER;
     const database = env.DB_NAME;
     if (!user) {
-      throw new EnvParseError("\u4F7F\u7528\u5143\u4EF6\u683C\u5F0F\u6642 DB_USER \u70BA\u5FC5\u9700");
+      throw new EnvParseError("DB_USER is required when using component format");
     }
     if (!database) {
-      throw new EnvParseError("\u4F7F\u7528\u5143\u4EF6\u683C\u5F0F\u6642 DB_NAME \u70BA\u5FC5\u9700");
+      throw new EnvParseError("DB_NAME is required when using component format");
     }
     const defaults = getDefaultsForSystem(system);
     const port = env.DB_PORT ? parseInt(env.DB_PORT, 10) : defaults.port || 5432;
     if (isNaN(port) || port < 1 || port > 65535) {
-      throw new EnvParseError(`DB_PORT \u5FC5\u9808\u5728 1 \u5230 65535 \u4E4B\u9593\uFF0C\u5F97\u5230: ${env.DB_PORT}`);
+      throw new EnvParseError(`DB_PORT must be between 1 and 65535, got: ${env.DB_PORT}`);
     }
     return {
       system,
@@ -47192,7 +47305,7 @@ var ConnectionConfigSchema = exports_external.object({
   password: exports_external.union([exports_external.string(), EnvRefSchema]).default(""),
   database: StringOrEnvRef
 });
-var PermissionSchema = exports_external.enum(["query-only", "read-write", "admin"]).default("query-only");
+var PermissionSchema = exports_external.enum(["query-only", "read-write", "data-admin", "admin"]).default("query-only");
 var MetadataSchema = exports_external.object({
   createdAt: exports_external.string().datetime().optional(),
   version: exports_external.string().default("1.0")
@@ -47237,14 +47350,14 @@ function resolveEnvReferences(config, env, parentKey, strict = false) {
       if (!strict) {
         return config;
       }
-      throw new ConfigError(`\u74B0\u5883\u8B8A\u91CF\u672A\u5B9A\u7FA9: ${envKey}
-` + `\u8ACB\u5728 .env \u6216\u74B0\u5883\u8B8A\u91CF\u4E2D\u8A2D\u7F6E ${envKey}\u3002
-` + `\u63D0\u793A: \u6AA2\u67E5 .env \u6587\u4EF6\u6216\u57F7\u884C 'export ${envKey}=<\u503C>'`);
+      throw new ConfigError(`Environment variable not defined: ${envKey}
+` + `Please set ${envKey} in .env or your environment.
+` + `Hint: check your .env file or run 'export ${envKey}=<value>'`);
     }
     if (parentKey === "port") {
       const portNum = parseInt(value, 10);
       if (isNaN(portNum) || portNum < 1 || portNum > 65535) {
-        throw new ConfigError(`${envKey} \u5FC5\u9808\u662F\u6709\u6548\u7684\u7AEF\u53E3\u865F (1-65535)\uFF0C\u5F97\u5230: ${value}`);
+        throw new ConfigError(`${envKey} must be a valid port number (1-65535), got: ${value}`);
       }
       return portNum;
     }
@@ -47307,9 +47420,9 @@ var configModule = {
       return { ...DEFAULT_CONFIG };
     } catch (error) {
       if (error instanceof Error && error.message.includes("JSON")) {
-        throw new ConfigError(`\u7121\u6CD5\u89E3\u6790 .dbcli \u6587\u4EF6\uFF1A${error.message}`);
+        throw new ConfigError(`Failed to parse .dbcli file: ${error.message}`);
       }
-      throw new ConfigError(`\u7121\u6CD5\u8B80\u53D6 .dbcli \u914D\u7F6E: ${error instanceof Error ? error.message : String(error)}`);
+      throw new ConfigError(`Failed to read .dbcli config: ${error instanceof Error ? error.message : String(error)}`);
     }
   },
   validate(raw) {
@@ -47317,7 +47430,7 @@ var configModule = {
       return DbcliConfigSchema.parse(raw);
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      throw new ConfigError(`\u7121\u6548\u7684 .dbcli \u914D\u7F6E\u7D50\u69CB: ${errorMessage}`);
+      throw new ConfigError(`Invalid .dbcli config structure: ${errorMessage}`);
     }
   },
   merge(existing, updates) {
@@ -47367,8 +47480,7 @@ var configModule = {
           await Bun.file(configPath).write(configJson);
           if (password) {
             const envPath = join(path, ".env.local");
-            const envContent = `# \u8CC7\u6599\u5EAB\u654F\u611F\u4FE1\u606F - \u8ACB\u52FF\u63D0\u4EA4\u5230 git
-# Database Credentials - DO NOT commit to git
+            const envContent = `# Database Credentials - DO NOT commit to git
 
 DBCLI_PASSWORD=${password}
 `;
@@ -47383,7 +47495,7 @@ DBCLI_PASSWORD=${password}
       if (error instanceof ConfigError) {
         throw error;
       }
-      throw new ConfigError(`\u7121\u6CD5\u5BEB\u5165 .dbcli \u914D\u7F6E: ${error instanceof Error ? error.message : String(error)}`);
+      throw new ConfigError(`Failed to write .dbcli config: ${error instanceof Error ? error.message : String(error)}`);
     }
   }
 };
@@ -47498,37 +47610,37 @@ function mapError(error, system, options) {
   const errMsg = String(err?.message || String(error));
   const errCode = String(err?.code || "");
   if (errCode === "ECONNREFUSED" || errMsg.includes("refused")) {
-    return new ConnectionError("ECONNREFUSED", `\u7121\u6CD5\u9023\u63A5\u81F3 ${options.host}:${options.port} \u2014 \u4F3A\u670D\u5668\u672A\u904B\u884C\u6216\u672A\u76E3\u807D\u8A72\u57E0\u865F`, [
-      `\u78BA\u8A8D ${system} \u670D\u52D9\u5DF2\u555F\u52D5: ${system === "postgresql" ? "systemctl status postgresql" : "systemctl status mysql"}`,
-      `\u78BA\u8A8D\u57E0\u865F\u6B63\u78BA: ${system === "postgresql" ? "\u9810\u8A2D 5432" : "\u9810\u8A2D 3306"}`,
-      `\u6AA2\u67E5 ${options.host} \u662F\u5426\u53EF\u9054: ping ${options.host} \u6216 telnet ${options.host} ${options.port}`
+    return new ConnectionError("ECONNREFUSED", `Cannot connect to ${options.host}:${options.port} \u2014 server is not running or not listening on this port`, [
+      `Check that the ${system} service is running: ${system === "postgresql" ? "systemctl status postgresql" : "systemctl status mysql"}`,
+      `Verify the port is correct: ${system === "postgresql" ? "default 5432" : "default 3306"}`,
+      `Check that ${options.host} is reachable: ping ${options.host} or telnet ${options.host} ${options.port}`
     ]);
   }
   if (errCode === "ETIMEDOUT" || errMsg.includes("timeout") || errMsg.includes("timed out")) {
-    return new ConnectionError("ETIMEDOUT", `\u9023\u63A5\u8D85\u6642 (${options.timeout || 5000}ms) \u2014 \u53EF\u80FD\u662F\u9632\u706B\u7246\u963B\u64CB\u6216\u7DB2\u8DEF\u5EF6\u9072`, [
-      `\u6AA2\u67E5\u9632\u706B\u7246: ${system === "postgresql" ? "\u5141\u8A31 TCP 5432" : "\u5141\u8A31 TCP 3306"}`,
-      `\u589E\u52A0\u8D85\u6642\u6642\u9593: \u7DE8\u8F2F .dbcli \u4E26\u65B0\u589E "timeout": 15000`,
-      `\u78BA\u8A8D\u7DB2\u8DEF\u9023\u63A5: ping ${options.host} -c 3`
+    return new ConnectionError("ETIMEDOUT", `Connection timed out (${options.timeout || 5000}ms) \u2014 may be blocked by a firewall or slow network`, [
+      `Check firewall rules: ${system === "postgresql" ? "allow TCP 5432" : "allow TCP 3306"}`,
+      `Increase timeout: edit .dbcli and add "timeout": 15000`,
+      `Verify network connectivity: ping ${options.host} -c 3`
     ]);
   }
   if (errMsg.includes("authentication") || errMsg.includes("auth") || errMsg.includes("password") || errMsg.includes("access denied") || errMsg.includes("FATAL")) {
-    return new ConnectionError("AUTH_FAILED", `\u8A8D\u8B49\u5931\u6557 \u2014 \u6AA2\u67E5\u4F7F\u7528\u8005\u540D\u7A31\u6216\u5BC6\u78BC`, [
-      `\u9A57\u8B49\u8A8D\u8B49: ${system === "postgresql" ? `psql -U ${options.user} -h ${options.host}` : `mysql -u ${options.user} -h ${options.host}`}`,
-      `\u6AA2\u67E5 pg_hba.conf (PostgreSQL) \u6216 user privileges (MySQL)`,
-      `\u91CD\u65B0\u57F7\u884C dbcli init \u4EE5\u66F4\u65B0\u8A8D\u8B49`
+    return new ConnectionError("AUTH_FAILED", `Authentication failed \u2014 check your username or password`, [
+      `Verify credentials: ${system === "postgresql" ? `psql -U ${options.user} -h ${options.host}` : `mysql -u ${options.user} -h ${options.host}`}`,
+      `Check pg_hba.conf (PostgreSQL) or user privileges (MySQL)`,
+      `Re-run dbcli init to update credentials`
     ]);
   }
   if (errCode === "ENOTFOUND" || errMsg.includes("not found") || errMsg.includes("getaddrinfo")) {
-    return new ConnectionError("ENOTFOUND", `\u627E\u4E0D\u5230\u4E3B\u6A5F: ${options.host}`, [
-      `\u6AA2\u67E5\u4E3B\u6A5F\u540D\u62FC\u5BEB: ${options.host}`,
-      `\u78BA\u8A8D DNS \u53EF\u89E3\u6790: nslookup ${options.host}`,
-      `\u82E5\u4F7F\u7528 localhost\uFF0C\u8A66\u8A66 127.0.0.1 (IPv4 vs IPv6 \u554F\u984C)`
+    return new ConnectionError("ENOTFOUND", `Host not found: ${options.host}`, [
+      `Check the hostname spelling: ${options.host}`,
+      `Verify DNS resolution: nslookup ${options.host}`,
+      `If using localhost, try 127.0.0.1 (IPv4 vs IPv6 issue)`
     ]);
   }
-  return new ConnectionError("UNKNOWN", `\u9023\u63A5\u5931\u6557: ${errMsg}`, [
-    `\u6AA2\u67E5\u9023\u63A5\u53C3\u6578: host=${options.host}, port=${options.port}, user=${options.user}`,
-    `\u67E5\u770B\u4F3A\u670D\u5668\u65E5\u8A8C: ${system === "postgresql" ? "postgresql.log" : "mysql.log"}`,
-    `\u5617\u8A66\u76F4\u63A5\u7528 ${system === "postgresql" ? "psql" : "mysql"} \u547D\u4EE4\u884C\u5DE5\u5177\u6E2C\u8A66`
+  return new ConnectionError("UNKNOWN", `Connection failed: ${errMsg}`, [
+    `Check connection parameters: host=${options.host}, port=${options.port}, user=${options.user}`,
+    `View server logs: ${system === "postgresql" ? "postgresql.log" : "mysql.log"}`,
+    `Try connecting directly with the ${system === "postgresql" ? "psql" : "mysql"} command-line tool`
   ]);
 }
 
@@ -47554,7 +47666,7 @@ class PostgreSQLAdapter {
   constructor(options) {
     this.options = options;
     if (options.port < 1 || options.port > 65535) {
-      throw new Error(`\u7121\u6548\u7684\u57E0\u865F: ${options.port}`);
+      throw new Error(`Invalid port number: ${options.port}`);
     }
   }
   async connect() {
@@ -47587,7 +47699,7 @@ class PostgreSQLAdapter {
   }
   async testConnection() {
     if (!this.pool) {
-      throw new ConnectionError("UNKNOWN", "\u8CC7\u6599\u5EAB\u9023\u63A5\u672A\u5EFA\u7ACB", ["\u547C\u53EB connect() \u4EE5\u5EFA\u7ACB\u9023\u63A5"]);
+      throw new ConnectionError("UNKNOWN", "Database connection not established", ["Call connect() to establish a connection"]);
     }
     try {
       const result = await this.execute("SELECT 1 as count");
@@ -47598,7 +47710,7 @@ class PostgreSQLAdapter {
   }
   async execute(sql, params) {
     if (!this.pool) {
-      throw new ConnectionError("UNKNOWN", "\u8CC7\u6599\u5EAB\u9023\u63A5\u672A\u5EFA\u7ACB", ["\u547C\u53EB connect() \u4EE5\u5EFA\u7ACB\u9023\u63A5"]);
+      throw new ConnectionError("UNKNOWN", "Database connection not established", ["Call connect() to establish a connection"]);
     }
     try {
       const result = params ? await this.pool.query(sql, params) : await this.pool.query(sql);
@@ -47609,7 +47721,7 @@ class PostgreSQLAdapter {
   }
   async listTables() {
     if (!this.pool) {
-      throw new ConnectionError("UNKNOWN", "\u8CC7\u6599\u5EAB\u9023\u63A5\u672A\u5EFA\u7ACB", ["\u547C\u53EB connect() \u4EE5\u5EFA\u7ACB\u9023\u63A5"]);
+      throw new ConnectionError("UNKNOWN", "Database connection not established", ["Call connect() to establish a connection"]);
     }
     try {
       const query = `
@@ -47621,7 +47733,9 @@ class PostgreSQLAdapter {
             WHEN 'v' THEN 'view'
             WHEN 'm' THEN 'view'
             ELSE 'table'
-          END as table_type
+          END as table_type,
+          (SELECT COUNT(*) FROM information_schema.columns ic
+           WHERE ic.table_schema = 'public' AND ic.table_name = c.relname)::int as column_count
         FROM pg_class c
         JOIN pg_namespace n ON n.oid = c.relnamespace
         WHERE n.nspname = 'public'
@@ -47632,6 +47746,7 @@ class PostgreSQLAdapter {
       return results.map((row) => ({
         name: row.table_name,
         columns: [],
+        columnCount: row.column_count,
         rowCount: Math.max(0, row.estimated_rows || 0),
         engine: "PostgreSQL",
         estimatedRowCount: Math.max(0, row.estimated_rows || 0),
@@ -47643,7 +47758,7 @@ class PostgreSQLAdapter {
   }
   async getTableSchema(tableName) {
     if (!this.pool) {
-      throw new ConnectionError("UNKNOWN", "\u8CC7\u6599\u5EAB\u9023\u63A5\u672A\u5EFA\u7ACB", ["\u547C\u53EB connect() \u4EE5\u5EFA\u7ACB\u9023\u63A5"]);
+      throw new ConnectionError("UNKNOWN", "Database connection not established", ["Call connect() to establish a connection"]);
     }
     try {
       const columnQuery = `
@@ -47801,7 +47916,7 @@ class MySQLAdapter {
     this.options = options;
     this.system = options.system === "mariadb" ? "mariadb" : "mysql";
     if (options.port < 1 || options.port > 65535) {
-      throw new Error(`\u7121\u6548\u7684\u57E0\u865F: ${options.port}`);
+      throw new Error(`Invalid port number: ${options.port}`);
     }
   }
   async connect() {
@@ -47828,7 +47943,7 @@ class MySQLAdapter {
   }
   async testConnection() {
     if (!this.db) {
-      throw new ConnectionError("UNKNOWN", "\u8CC7\u6599\u5EAB\u9023\u63A5\u672A\u5EFA\u7ACB", ["\u547C\u53EB connect() \u4EE5\u5EFA\u7ACB\u9023\u63A5"]);
+      throw new ConnectionError("UNKNOWN", "Database connection not established", ["Call connect() to establish a connection"]);
     }
     try {
       const result = await this.execute("SELECT 1 as count");
@@ -47839,7 +47954,7 @@ class MySQLAdapter {
   }
   async execute(sql, params) {
     if (!this.db) {
-      throw new ConnectionError("UNKNOWN", "\u8CC7\u6599\u5EAB\u9023\u63A5\u672A\u5EFA\u7ACB", ["\u547C\u53EB connect() \u4EE5\u5EFA\u7ACB\u9023\u63A5"]);
+      throw new ConnectionError("UNKNOWN", "Database connection not established", ["Call connect() to establish a connection"]);
     }
     try {
       const [rows] = params ? await this.db.execute(sql, params) : await this.db.execute(sql);
@@ -47850,7 +47965,7 @@ class MySQLAdapter {
   }
   async listTables() {
     if (!this.db) {
-      throw new ConnectionError("UNKNOWN", "\u8CC7\u6599\u5EAB\u9023\u63A5\u672A\u5EFA\u7ACB", ["\u547C\u53EB connect() \u4EE5\u5EFA\u7ACB\u9023\u63A5"]);
+      throw new ConnectionError("UNKNOWN", "Database connection not established", ["Call connect() to establish a connection"]);
     }
     try {
       const query = `
@@ -47870,7 +47985,8 @@ class MySQLAdapter {
       const results = await this.execute(query);
       return results.map((row) => ({
         name: row.table_name,
-        columns: Array(row.column_count).fill(null),
+        columns: [],
+        columnCount: row.column_count,
         rowCount: row.row_count || 0,
         engine: row.engine,
         estimatedRowCount: row.row_count || 0,
@@ -47882,7 +47998,7 @@ class MySQLAdapter {
   }
   async getTableSchema(tableName) {
     if (!this.db) {
-      throw new ConnectionError("UNKNOWN", "\u8CC7\u6599\u5EAB\u9023\u63A5\u672A\u5EFA\u7ACB", ["\u547C\u53EB connect() \u4EE5\u5EFA\u7ACB\u9023\u63A5"]);
+      throw new ConnectionError("UNKNOWN", "Database connection not established", ["Call connect() to establish a connection"]);
     }
     try {
       const columnQuery = `
@@ -47993,12 +48109,12 @@ class AdapterFactory {
       case "mariadb":
         return new MySQLAdapter(options);
       default:
-        throw new Error(`\u4E0D\u652F\u6301\u7684\u8CC7\u6599\u5EAB\u7CFB\u7D71: ${options.system}`);
+        throw new Error(`Unsupported database system: ${options.system}`);
     }
   }
 }
 // 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, 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 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) => {
   try {
     await initCommandHandler(options);
   } catch (error) {
@@ -48061,7 +48177,7 @@ async function initCommandHandler(options) {
         "admin"
       ]);
     }
-    if (!["query-only", "read-write", "admin"].includes(permission2)) {
+    if (!["query-only", "read-write", "data-admin", "admin"].includes(permission2)) {
       throw new Error(`Invalid permission level: ${permission2}`);
     }
     const newConfig2 = configModule.merge(existingConfig, {
@@ -48107,10 +48223,11 @@ async function initCommandHandler(options) {
     permission = await promptUser.select(t("init.prompt_permission"), [
       "query-only",
       "read-write",
+      "data-admin",
       "admin"
     ]);
   }
-  if (!["query-only", "read-write", "admin"].includes(permission)) {
+  if (!["query-only", "read-write", "data-admin", "admin"].includes(permission)) {
     throw new Error(`Invalid permission level: ${permission}`);
   }
   configForWrite = connection;
@@ -48205,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]
     });
@@ -48231,14 +48348,14 @@ 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]
     });
     tables.forEach((t2) => {
       table.push([
         t2.name,
-        t2.columns.length.toString(),
+        (t2.columnCount ?? t2.columns.length).toString(),
         (t2.rowCount ?? "?").toString(),
         t2.engine || "N/A"
       ]);
@@ -48248,14 +48365,6 @@ class TableListFormatter {
 }
 // src/formatters/json-formatter.ts
 init_size_category();
-
-class JSONFormatter {
-  format(data, options) {
-    const spacing = options?.compact ? undefined : 2;
-    return JSON.stringify(data, null, spacing);
-  }
-}
-
 class TableSchemaJSONFormatter {
   format(table, options) {
     const spacing = options?.compact ? undefined : 2;
@@ -48413,8 +48522,15 @@ async function listAction(options) {
         return;
       }
       if (options.format === "json") {
-        const formatter = new JSONFormatter;
-        console.log(formatter.format(tables, { compact: false }));
+        const listOutput = tables.map((t2) => ({
+          name: t2.name,
+          columnCount: t2.columnCount ?? t2.columns.length,
+          rowCount: t2.rowCount ?? 0,
+          engine: t2.engine,
+          estimatedRowCount: t2.estimatedRowCount ?? t2.rowCount ?? 0,
+          tableType: t2.tableType ?? "table"
+        }));
+        console.log(JSON.stringify(listOutput, null, 2));
       } else {
         const formatter = new TableListFormatter;
         console.log(formatter.format(tables));
@@ -48709,9 +48825,9 @@ async function handleFullDatabaseScan(adapter, config, options) {
   };
   await configModule.write(options.config, updatedConfig);
   console.log(`
-\u2705 \u67B6\u69CB\u5DF2\u5728 .dbcli \u4E2D\u66F4\u65B0`);
-  console.log(`   ${tables.length} \u500B\u8868\u683C\u53CA\u5B8C\u6574\u5217\u8A73\u60C5\u548C\u95DC\u4FC2`);
-  console.log(`   \u6642\u9593\u6233: ${updatedConfig.metadata.schemaLastUpdated}`);
+\u2705 Schema updated in .dbcli`);
+  console.log(`   ${tables.length} tables with full column details and relationships`);
+  console.log(`   Timestamp: ${updatedConfig.metadata.schemaLastUpdated}`);
 }
 
 // src/core/permission-guard.ts
@@ -48934,6 +49050,29 @@ function checkPermission(sql, permission) {
       classification
     };
   }
+  if (permission === "data-admin") {
+    const allowedTypes = [
+      "SELECT",
+      "INSERT",
+      "UPDATE",
+      "DELETE",
+      "SHOW",
+      "DESCRIBE",
+      "EXPLAIN"
+    ];
+    if (allowedTypes.includes(classification.type)) {
+      return {
+        allowed: true,
+        reason: `${classification.type} operation allowed in data-admin mode`,
+        classification
+      };
+    }
+    return {
+      allowed: false,
+      reason: `${classification.type} operation requires admin permission`,
+      classification
+    };
+  }
   if (permission === "read-write") {
     const allowedTypes = [
       "SELECT",
@@ -48952,7 +49091,7 @@ function checkPermission(sql, permission) {
     }
     return {
       allowed: false,
-      reason: `${classification.type} operation requires admin permission`,
+      reason: `${classification.type} operation requires data-admin or admin permission`,
       classification
     };
   }
@@ -49438,7 +49577,7 @@ class DataExecutor {
     const dataKeys = Object.keys(data);
     for (const key2 of dataKeys) {
       if (!columnNames.includes(key2)) {
-        throw new Error(`\u8CC7\u6599\u8868 "${tableName}" \u4E2D\u627E\u4E0D\u5230\u6B04\u4F4D "${key2}"\u3002\u6709\u6548\u7684\u6B04\u4F4D: ${columnNames.join(", ")}`);
+        throw new Error(`Column "${key2}" not found in table "${tableName}". Valid columns: ${columnNames.join(", ")}`);
       }
     }
     const columns = dataKeys;
@@ -49471,12 +49610,12 @@ class DataExecutor {
       }
       if (!options?.force) {
         console.log(`
-\u751F\u6210\u7684 SQL:`);
+Generated SQL:`);
         console.log(`  ${sql}`);
         console.log(`
-\u53C3\u6578:`);
+Parameters:`);
         console.log(`  ${JSON.stringify(params, null, 2)}`);
-        const confirmed = await promptUser.confirm("\u662F\u5426\u57F7\u884C\u6B64\u64CD\u4F5C?");
+        const confirmed = await promptUser.confirm("Proceed with this operation?");
         if (!confirmed) {
           return {
             status: "success",
@@ -49507,7 +49646,7 @@ class DataExecutor {
           operation: "insert",
           rows_affected: 0,
           timestamp,
-          error: "\u6B0A\u9650\u88AB\u62D2: Query-only \u6A21\u5F0F\u50C5\u5141\u8A31 SELECT\u3002\u4F7F\u7528 Read-Write \u6216 Admin \u6A21\u5F0F\u57F7\u884C INSERT\u3002"
+          error: "Permission denied: Query-only mode only allows SELECT. Use Read-Write or Admin mode to execute INSERT."
         };
       }
       return {
@@ -49515,7 +49654,7 @@ class DataExecutor {
         operation: "insert",
         rows_affected: 0,
         timestamp,
-        error: `INSERT \u5931\u6557: ${errorMessage}`
+        error: `INSERT failed: ${errorMessage}`
       };
     }
   }
@@ -49538,12 +49677,12 @@ class DataExecutor {
       }
       if (!options?.force) {
         console.log(`
-\u751F\u6210\u7684 SQL:`);
+Generated SQL:`);
         console.log(`  ${sql}`);
         console.log(`
-\u53C3\u6578:`);
+Parameters:`);
         console.log(`  ${JSON.stringify(params, null, 2)}`);
-        const confirmed = await promptUser.confirm("\u662F\u5426\u57F7\u884C\u6B64\u64CD\u4F5C?");
+        const confirmed = await promptUser.confirm("Proceed with this operation?");
         if (!confirmed) {
           return {
             status: "success",
@@ -49574,7 +49713,7 @@ class DataExecutor {
           operation: "update",
           rows_affected: 0,
           timestamp,
-          error: "\u6B0A\u9650\u88AB\u62D2: Query-only \u6A21\u5F0F\u50C5\u5141\u8A31 SELECT\u3002\u4F7F\u7528 Read-Write \u6216 Admin \u6A21\u5F0F\u57F7\u884C UPDATE\u3002"
+          error: "Permission denied: Query-only mode only allows SELECT. Use Read-Write or Admin mode to execute UPDATE."
         };
       }
       return {
@@ -49582,7 +49721,7 @@ class DataExecutor {
         operation: "update",
         rows_affected: 0,
         timestamp,
-        error: `UPDATE \u5931\u6557: ${errorMessage}`
+        error: `UPDATE failed: ${errorMessage}`
       };
     }
   }
@@ -49592,13 +49731,13 @@ class DataExecutor {
       if (this.blacklistValidator) {
         this.blacklistValidator.checkTableBlacklist("DELETE", tableName, []);
       }
-      if (this.permission !== "admin") {
+      if (this.permission !== "data-admin" && this.permission !== "admin") {
         return {
           status: "error",
           operation: "delete",
           rows_affected: 0,
           timestamp,
-          error: "\u6B0A\u9650\u88AB\u62D2: DELETE \u64CD\u4F5C\u9700\u8981 Admin \u6B0A\u9650\u3002"
+          error: "Permission denied: DELETE operation requires Data-Admin or Admin permission."
         };
       }
       const { sql, params } = this.buildDeleteSql(tableName, where, schema);
@@ -49613,14 +49752,14 @@ class DataExecutor {
       }
       if (!options?.force) {
         console.log(`
-\u26A0\uFE0F  \u8B66\u544A: DELETE \u64CD\u4F5C\u662F\u7834\u58DE\u6027\u7684\uFF0C\u7121\u6CD5\u64A4\u92B7\uFF01`);
+\u26A0\uFE0F  Warning: DELETE operation is destructive and cannot be undone!`);
         console.log(`
-\u751F\u6210\u7684 SQL:`);
+Generated SQL:`);
         console.log(`  ${sql}`);
         console.log(`
-\u53C3\u6578:`);
+Parameters:`);
         console.log(`  ${JSON.stringify(params, null, 2)}`);
-        const confirmed = await promptUser.confirm("\u662F\u5426\u771F\u7684\u8981\u57F7\u884C\u6B64 DELETE \u64CD\u4F5C? \u6B64\u64CD\u4F5C\u7121\u6CD5\u64A4\u92B7\u3002");
+        const confirmed = await promptUser.confirm("Are you sure you want to execute this DELETE operation? This cannot be undone.");
         if (!confirmed) {
           return {
             status: "success",
@@ -49650,7 +49789,7 @@ class DataExecutor {
         operation: "delete",
         rows_affected: 0,
         timestamp,
-        error: `DELETE \u5931\u6557: ${errorMessage}`
+        error: `DELETE failed: ${errorMessage}`
       };
     }
   }
@@ -49666,7 +49805,7 @@ class DataExecutor {
     const columnNames = schema.columns.map((col) => col.name);
     for (const key2 of [...dataKeys, ...whereKeys]) {
       if (!columnNames.includes(key2)) {
-        throw new Error(`\u8CC7\u6599\u8868 "${tableName}" \u4E2D\u627E\u4E0D\u5230\u6B04\u4F4D "${key2}"`);
+        throw new Error(`Column "${key2}" not found in table "${tableName}"`);
       }
     }
     const systemType = this.getSystemType();
@@ -49689,7 +49828,7 @@ class DataExecutor {
     const columnNames = schema.columns.map((col) => col.name);
     for (const key2 of whereKeys) {
       if (!columnNames.includes(key2)) {
-        throw new Error(`\u8CC7\u6599\u8868 "${tableName}" \u4E2D\u627E\u4E0D\u5230\u6B04\u4F4D "${key2}"`);
+        throw new Error(`Column "${key2}" not found in table "${tableName}"`);
       }
     }
     const systemType = this.getSystemType();
@@ -49983,7 +50122,7 @@ async function deleteCommand(table, options) {
     if (!config.connection) {
       throw new Error('Run "dbcli init" to configure database connection');
     }
-    if (config.permission !== "admin") {
+    if (config.permission !== "data-admin" && config.permission !== "admin") {
       throw new PermissionError(t("delete.admin_only"), { type: "DELETE", isDangerous: true, keywords: ["DELETE"], isComposite: false, confidence: "HIGH" }, config.permission);
     }
     const adapter = AdapterFactory.createAdapter(config.connection);
@@ -50025,7 +50164,7 @@ async function deleteCommand(table, options) {
       process.exit(1);
     }
     if (error instanceof PermissionError) {
-      console.error(t_vars("errors.permission_denied", { required: "admin" }));
+      console.error(t_vars("errors.permission_denied", { required: "data-admin" }));
       console.error(`   Operation: ${error.classification.type}`);
       console.error(`   Message: ${error.message}`);
       process.exit(1);
@@ -50099,7 +50238,17 @@ async function exportCommand(sql, options) {
 // src/commands/skill.ts
 import * as path from "path";
 import { homedir } from "os";
-var SKILL_SOURCE_PATH = path.resolve(import.meta.dir, "../../assets/SKILL.md");
+function findPackageRoot() {
+  let dir = import.meta.dir;
+  for (let i = 0;i < 5; i++) {
+    if (Bun.file(path.join(dir, "package.json")).size > 0) {
+      return dir;
+    }
+    dir = path.dirname(dir);
+  }
+  return path.resolve(import.meta.dir, "../..");
+}
+var SKILL_SOURCE_PATH = path.join(findPackageRoot(), "assets", "SKILL.md");
 async function skillCommand(_program, options) {
   try {
     const skillFile = Bun.file(SKILL_SOURCE_PATH);
@@ -50753,8 +50902,671 @@ Schema diff (${beforeSnapshot.createdAt} -> ${currentSnapshot.createdAt}):`);
   }
 }
 
+// src/commands/status.ts
+var statusCommand = new Command("status").description("Show current configuration status (safe for AI agents, no credentials exposed)").option("--format <type>", "Output format: text, json", "json").action(async (options) => {
+  try {
+    const config = await configModule.read(".dbcli");
+    if (!config.connection) {
+      console.error('No configuration found. Run "dbcli init" first.');
+      process.exit(1);
+    }
+    const blacklistTables = config.blacklist?.tables ?? [];
+    const blacklistColumns = config.blacklist?.columns ?? {};
+    const columnCount = Object.values(blacklistColumns).reduce((sum, cols) => sum + cols.length, 0);
+    const status = {
+      permission: config.permission,
+      system: config.connection.system,
+      blacklist: {
+        tables: blacklistTables.length,
+        columns: columnCount
+      },
+      version: config.metadata?.version ?? "unknown"
+    };
+    if (options.format === "text") {
+      console.log(`Permission: ${status.permission}`);
+      console.log(`System:     ${status.system}`);
+      console.log(`Blacklist:  ${status.blacklist.tables} table(s), ${status.blacklist.columns} column(s)`);
+      console.log(`Version:    ${status.version}`);
+    } else {
+      console.log(JSON.stringify(status, null, 2));
+    }
+  } catch (error) {
+    console.error(`Error: ${error.message}`);
+    process.exit(1);
+  }
+});
+
+// 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);
@@ -50813,6 +51625,10 @@ program2.command("skill").description(t("skill.description")).option("--install
 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();
 }