@ddt-tools/cli 0.2.0

package/dist/index.cjs

@@ -0,0 +1,1288 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  catalogCommand: () => catalogCommand,
+  compareProfilesCommand: () => compareProfilesCommand,
+  connectionCommand: () => connectionCommand,
+  execCommand: () => execCommand,
+  explorerCommand: () => explorerCommand,
+  queryLogCommand: () => queryLogCommand,
+  saferAlternativeCommand: () => saferAlternativeCommand,
+  safetyCommand: () => safetyCommand,
+  scaffoldCommand: () => scaffoldCommand,
+  searchCommand: () => searchCommand,
+  sketchCommand: () => sketchCommand
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/commands/connection.ts
+var import_commander = require("commander");
+var import_core = require("@ddt-tools/core");
+function connectionCommand() {
+  const cmd = new import_commander.Command("connection").description("Manage Databricks connection profiles.");
+  cmd.command("add <name>").description("Store a new connection profile.").option("--host <host>", "Workspace host, e.g. dbc-12345-abcd.cloud.databricks.com").option("--auth <method>", "One of: pat | oauth-m2m | oauth-u2m | azure-ad | google-idc", "pat").option(
+    "--token <token>",
+    "PAT token \u2014 use env:DATABRICKS_TOKEN to reference an env var, never inline a secret"
+  ).option("--client-id <id>", "OAuth M2M / Azure AD client ID").option("--client-secret <secret>", "OAuth M2M / Azure AD client secret").option("--tenant-id <id>", "Azure AD tenant ID").option(
+    "--service-account-key-path <path>",
+    "Path to a GCP service-account key JSON file (for google-idc auth)"
+  ).requiredOption("--warehouse-id <id>", "SQL warehouse ID for DDL operations").option("--catalog <catalog>", "Default Unity Catalog catalog").option("--schema <schema>", "Default schema").action(async (name, opts) => {
+    if (!opts.host) throw new Error("--host is required");
+    const auth = buildAuth(opts);
+    const profile = {
+      name,
+      platform: "Databricks",
+      auth,
+      warehouseId: String(opts.warehouseId),
+      ...opts.catalog ? { catalog: String(opts.catalog) } : {},
+      ...opts.schema ? { schema: String(opts.schema) } : {}
+    };
+    await (0, import_core.upsertProfile)(profile);
+    console.log(`Saved profile "${name}" \u2192 ${(0, import_core.defaultProfilesPath)()}`);
+  });
+  cmd.command("list").description("List configured Databricks profiles.").action(async () => {
+    const profiles = await (0, import_core.loadProfiles)();
+    if (profiles.length === 0) {
+      console.log(`(no profiles configured at ${(0, import_core.defaultProfilesPath)()})`);
+      return;
+    }
+    for (const p of profiles) {
+      console.log(`${p.name}	${p.auth.method}	${p.auth.host}	warehouse=${p.warehouseId}`);
+    }
+  });
+  cmd.command("get <name>").description("Print a profile (secrets are redacted).").action(async (name) => {
+    const p = await (0, import_core.getProfile)(name);
+    const redacted = {
+      ...p,
+      auth: redactAuth(p.auth)
+    };
+    console.log(JSON.stringify(redacted, null, 2));
+  });
+  cmd.command("remove <name>").description("Delete a connection profile.").action(async (name) => {
+    const removed = await (0, import_core.removeProfile)(name);
+    console.log(removed ? `Removed profile "${name}".` : `No profile "${name}" found.`);
+    if (!removed) process.exitCode = 1;
+  });
+  cmd.command("test <name>").description(
+    "Probe a connection profile via the workspace REST API (`/api/2.0/preview/scim/v2/Me`)."
+  ).action(async (name) => {
+    const profile = await (0, import_core.getProfile)(name);
+    const conn = (0, import_core.createConnection)(profile);
+    try {
+      await conn.connect();
+      const info = await conn.test();
+      console.log(`OK  ${name}`);
+      console.log(`  host:    ${profile.auth.host}`);
+      console.log(`  account: ${info.account}`);
+      console.log(`  version: ${info.version}`);
+    } catch (err) {
+      console.error(`FAIL ${name}: ${err instanceof Error ? err.message : String(err)}`);
+      process.exitCode = 1;
+    } finally {
+      await conn.disconnect();
+    }
+  });
+  return cmd;
+}
+function buildAuth(opts) {
+  const host = String(opts.host);
+  const method = String(opts.auth ?? "pat").toLowerCase();
+  switch (method) {
+    case "pat":
+    case "personal_access_token":
+      if (!opts.token) throw new Error("--token is required for PAT auth");
+      return { method: "PERSONAL_ACCESS_TOKEN", host, token: String(opts.token) };
+    case "oauth-m2m":
+    case "oauth_m2m":
+      if (!opts.clientId || !opts.clientSecret) {
+        throw new Error("--client-id and --client-secret are required for OAuth M2M");
+      }
+      return {
+        method: "OAUTH_M2M",
+        host,
+        clientId: String(opts.clientId),
+        clientSecret: String(opts.clientSecret)
+      };
+    case "oauth-u2m":
+    case "oauth_u2m":
+      return { method: "OAUTH_U2M", host };
+    case "azure-ad":
+    case "azure_ad":
+      if (!opts.tenantId || !opts.clientId) {
+        throw new Error("--tenant-id and --client-id are required for Azure AD");
+      }
+      return {
+        method: "AZURE_AD",
+        host,
+        tenantId: String(opts.tenantId),
+        clientId: String(opts.clientId),
+        ...opts.clientSecret ? { clientSecret: String(opts.clientSecret) } : {}
+      };
+    case "google-idc":
+    case "google_idc":
+      if (!opts.serviceAccountKeyPath) {
+        throw new Error("--service-account-key-path is required for google-idc auth");
+      }
+      return {
+        method: "GOOGLE_IDC",
+        host,
+        serviceAccountKeyPath: String(opts.serviceAccountKeyPath)
+      };
+    default:
+      throw new Error(`Unknown --auth value: ${method}`);
+  }
+}
+function redactAuth(auth) {
+  if (auth.method === "PERSONAL_ACCESS_TOKEN" && auth.token && !auth.token.startsWith("env:")) {
+    return { ...auth, token: "<redacted>" };
+  }
+  if (auth.method === "OAUTH_M2M" && auth.clientSecret && !auth.clientSecret.startsWith("env:")) {
+    return { ...auth, clientSecret: "<redacted>" };
+  }
+  if (auth.method === "AZURE_AD" && auth.clientSecret && !auth.clientSecret.startsWith("env:")) {
+    return { ...auth, clientSecret: "<redacted>" };
+  }
+  return auth;
+}
+
+// src/commands/scaffold.ts
+var import_commander2 = require("commander");
+function scaffoldCommand(name) {
+  return new import_commander2.Command(name).description(`${name} \u2014 Databricks (scaffold; later-release deliverable).`).action(() => {
+    console.error(
+      `ddt ${name}: scaffold \u2014 the Databricks engine for this command is a later deliverable.
+Track progress at Databricks/docs/ROADMAP.md.`
+    );
+    process.exitCode = 2;
+  });
+}
+
+// src/commands/safety.ts
+var import_commander3 = require("commander");
+var import_core2 = require("@ddt-tools/core");
+function safetyCommand() {
+  const cmd = new import_commander3.Command("safety");
+  cmd.description(
+    "Inspect the safety-finding catalog. See `ddt safety list` and `ddt safety explain <code>`."
+  );
+  cmd.command("list").description("List every known finding code with category + one-line summary.").option("--format <format>", "Output format: table | json", "table").option(
+    "--category <kind>",
+    "Filter to one category: unrecoverable | destructive | expensive | warning. Default: all."
+  ).action((opts) => {
+    const codes = import_core2.safety.listFindingCodes();
+    let entries = codes.map((c) => import_core2.safety.explainFinding(c)).filter((e) => e !== void 0);
+    if (opts.category) {
+      const want = opts.category.toUpperCase();
+      const valid = ["UNRECOVERABLE", "DESTRUCTIVE", "EXPENSIVE", "WARNING"];
+      if (!valid.includes(want)) {
+        console.error(
+          `Unknown --category "${opts.category}". Use one of: ${valid.join(" | ").toLowerCase()}.`
+        );
+        process.exitCode = 1;
+        return;
+      }
+      entries = entries.filter((e) => e.category === want);
+    }
+    if ((opts.format ?? "table") === "json") {
+      process.stdout.write(JSON.stringify(entries, null, 2) + "\n");
+      return;
+    }
+    if (entries.length === 0) {
+      console.log("(no entries match the filter)");
+      return;
+    }
+    printList(entries);
+  });
+  cmd.command("explain").description('Expand a finding code into a deep "why this is dangerous" page.').argument("<code>", "The finding code (e.g. DROP_UNRECOVERABLE, COLUMN_TYPE_CHANGE)").option("--format <format>", "Output format: text | json | markdown", "text").action((codeArg, opts) => {
+    const code = codeArg.toUpperCase();
+    const entry = import_core2.safety.explainFinding(code);
+    if (!entry) {
+      console.error(`Unknown safety finding code: "${codeArg}"`);
+      console.error("  Try: ddt safety list");
+      process.exitCode = 1;
+      return;
+    }
+    const format = (opts.format ?? "text").toLowerCase();
+    if (format === "json") {
+      process.stdout.write(JSON.stringify(entry, null, 2) + "\n");
+      return;
+    }
+    if (format === "markdown") {
+      process.stdout.write(renderMarkdown(entry) + "\n");
+      return;
+    }
+    printDeep(entry);
+  });
+  return cmd;
+}
+function printList(entries) {
+  const byCategory = /* @__PURE__ */ new Map();
+  for (const e of entries) {
+    const arr = byCategory.get(e.category) ?? [];
+    arr.push(e);
+    byCategory.set(e.category, arr);
+  }
+  const order = [
+    "UNRECOVERABLE",
+    "DESTRUCTIVE",
+    "EXPENSIVE",
+    "WARNING"
+  ];
+  for (const cat of order) {
+    const arr = byCategory.get(cat);
+    if (!arr || arr.length === 0) continue;
+    console.log(`# ${cat} (${arr.length})`);
+    for (const e of arr) {
+      console.log(`  ${e.code}`);
+      console.log(`    ${e.title}`);
+      console.log(`    ${e.summary}`);
+    }
+    console.log("");
+  }
+  console.log("Use `ddt safety explain <code>` for the full per-finding write-up.");
+}
+function printDeep(entry) {
+  console.log(`${entry.code}  [${entry.category}]`);
+  console.log(entry.title);
+  console.log("");
+  console.log("Summary");
+  console.log(`  ${entry.summary}`);
+  console.log("");
+  console.log("Why this is dangerous");
+  for (const line of wrap(entry.whyDangerous, 76)) {
+    console.log(`  ${line}`);
+  }
+  console.log("");
+  console.log("What cannot be reversed");
+  for (const item of entry.cannotBeReversed) console.log(`  - ${item}`);
+  console.log("");
+  console.log("Safer alternatives");
+  for (const item of entry.saferAlternatives) console.log(`  - ${item}`);
+  console.log("");
+  if (entry.requiredGates.length > 0) {
+    console.log("Required gates to allow this finding through");
+    for (const g of entry.requiredGates) console.log(`  - ${g}`);
+    console.log("");
+  }
+  if (entry.example) {
+    console.log("Example");
+    console.log(`  ${entry.example}`);
+  }
+}
+function renderMarkdown(entry) {
+  const lines = [];
+  lines.push(`## ${entry.code} \u2014 ${entry.title}`);
+  lines.push("");
+  lines.push(`**Category:** ${entry.category}`);
+  lines.push("");
+  lines.push(`**Summary:** ${entry.summary}`);
+  lines.push("");
+  lines.push("### Why this is dangerous");
+  lines.push(entry.whyDangerous);
+  lines.push("");
+  lines.push("### What cannot be reversed");
+  for (const item of entry.cannotBeReversed) lines.push(`- ${item}`);
+  lines.push("");
+  lines.push("### Safer alternatives");
+  for (const item of entry.saferAlternatives) lines.push(`- ${item}`);
+  if (entry.requiredGates.length > 0) {
+    lines.push("");
+    lines.push("### Required gates");
+    for (const g of entry.requiredGates) lines.push(`- \`${g}\``);
+  }
+  if (entry.example) {
+    lines.push("");
+    lines.push("### Example");
+    lines.push("```");
+    lines.push(entry.example);
+    lines.push("```");
+  }
+  return lines.join("\n");
+}
+function wrap(text, width) {
+  const words = text.split(/\s+/);
+  const lines = [];
+  let current = "";
+  for (const word of words) {
+    if (current.length === 0) {
+      current = word;
+    } else if (current.length + 1 + word.length <= width) {
+      current += " " + word;
+    } else {
+      lines.push(current);
+      current = word;
+    }
+  }
+  if (current.length > 0) lines.push(current);
+  return lines;
+}
+
+// src/commands/safer-alternative.ts
+var import_node_fs = require("fs");
+var import_commander4 = require("commander");
+var import_core3 = require("@ddt-tools/core");
+function saferAlternativeCommand() {
+  const cmd = new import_commander4.Command("safer-alternative");
+  cmd.description(
+    "AI-assist: propose a safer DDL alternative for a safety finding. Requires a configured AI provider (ddt ai status)."
+  ).requiredOption("--code <code>", "SafetyFindingCode (e.g. COLUMN_DROP, DROP_UNRECOVERABLE).").requiredOption("--fqn <fqn>", "Object FQN the finding refers to.").requiredOption("--object-type <type>", "Object type (e.g. MANAGED_TABLE, VIEW, FUNCTION).").requiredOption("--reason <text>", "Short reason text from the safety classifier.").option(
+    "--gate <gate>",
+    "Optional SafetyGate the finding raised (e.g. REQUIRE_ALLOW_DROP_COLUMN)."
+  ).option("--sql <path>", 'Path to a file with the dangerous DDL. Use "-" to read from stdin.').option("--context <path>", "Optional path to the surrounding source DDL.").option("--intent <text>", "Optional human-authored intent notes.").option("--format <fmt>", "Output format: text | json. Default text.", "text").option(
+    "--ai-max-spend <usd>",
+    "Refuse the call if today's estimated spend \u2265 this (USD). 0 = no cap.",
+    "0"
+  ).action(async (opts) => {
+    const dangerousSql = await readInput(
+      opts.sql,
+      '--sql is required (use a path or "-" for stdin).'
+    );
+    const contextSql = opts.context ? await import_node_fs.promises.readFile(String(opts.context), "utf8") : void 0;
+    const finding = {
+      code: String(opts.code),
+      category: "DESTRUCTIVE",
+      fqn: String(opts.fqn),
+      objectType: String(opts.objectType),
+      reason: String(opts.reason),
+      gate: opts.gate ? String(opts.gate) : void 0
+    };
+    const result = await import_core3.saferAlternative.suggestSaferAlternative(
+      {
+        finding,
+        dangerousSql,
+        contextSql,
+        intentNotes: opts.intent ? String(opts.intent) : void 0
+      },
+      {
+        completeFn: async (prompt) => {
+          const r = await import_core3.ai.complete([{ role: "user", content: prompt }], {
+            feature: "safer-alternative",
+            maxSpendUsd: Number(opts.aiMaxSpend ?? "0") || 0
+          });
+          return r.text;
+        }
+      }
+    );
+    if (String(opts.format).toLowerCase() === "json") {
+      const { rawModelText: _omit, ...keep } = result;
+      console.log(JSON.stringify(keep, null, 2));
+      return;
+    }
+    console.log(`Confidence: ${result.confidence}${result.parseFailed ? " (parse failed)" : ""}`);
+    console.log(`Reasoning: ${result.reasoning}`);
+    if (result.alternativeSql) {
+      console.log("");
+      console.log("--- Proposed safer DDL ---");
+      console.log(result.alternativeSql);
+    } else {
+      console.warn("No safer alternative SQL was returned.");
+    }
+    if (result.requiredGates.length > 0) {
+      console.log(`Required gates: ${result.requiredGates.join(", ")}`);
+    }
+  });
+  return cmd;
+}
+async function readInput(pathOrDash, missingMessage) {
+  if (!pathOrDash) throw new Error(missingMessage);
+  const p = String(pathOrDash);
+  if (p === "-") {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+      chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+    }
+    return Buffer.concat(chunks).toString("utf8");
+  }
+  return import_node_fs.promises.readFile(p, "utf8");
+}
+
+// src/commands/sketch.ts
+var import_node_fs2 = require("fs");
+var import_commander5 = require("commander");
+var import_core4 = require("@ddt-tools/core");
+var KINDS = [
+  "managed-table",
+  "external-table",
+  "streaming-table",
+  "materialized-view",
+  "view",
+  "function",
+  "volume"
+];
+function sketchCommand() {
+  const cmd = new import_commander5.Command("sketch");
+  cmd.description(
+    "AI-assist: scaffold idiomatic Databricks UC DDL from a prose description. Output always carries a REVIEW BEFORE DEPLOY header."
+  ).argument("<kind>", `Object kind: ${KINDS.join(" | ")}`).requiredOption("--description <text>", 'Free-form description. Use "-" to read from stdin.').option("--target <fqn>", "Target FQN (e.g. analytics.public.orders).").option("--context <text>", 'Optional additional context (e.g. "use SQL warehouse small").').option("--out <path>", "Output file. Default stdout.").option("--format <fmt>", "Output format: text | json. Default text.", "text").option(
+    "--ai-max-spend <usd>",
+    "Refuse the call if today's estimated spend \u2265 this (USD). 0 = no cap.",
+    "0"
+  ).action(async (kindArg, opts) => {
+    const kind = String(kindArg).toLowerCase();
+    if (!KINDS.includes(kind)) {
+      throw new Error(`Unknown kind "${kindArg}". Use one of: ${KINDS.join(" | ")}`);
+    }
+    const description = String(opts.description) === "-" ? await readStdin() : String(opts.description);
+    const targetFqn = opts.target ? splitFqn(String(opts.target)) : void 0;
+    const result = await import_core4.objectSketch.sketchToDdl(
+      {
+        description,
+        objectKind: kind,
+        targetFqn,
+        additionalContext: opts.context ? String(opts.context) : void 0
+      },
+      {
+        completeFn: async (prompt) => {
+          const r = await import_core4.ai.complete([{ role: "user", content: prompt }], {
+            feature: "object-sketch",
+            maxSpendUsd: Number(opts.aiMaxSpend ?? "0") || 0
+          });
+          return r.text;
+        }
+      }
+    );
+    const output = String(opts.format).toLowerCase() === "json" ? JSON.stringify({ ...result, rawModelText: void 0 }, null, 2) : result.generatedSql;
+    if (opts.out) {
+      await import_node_fs2.promises.writeFile(String(opts.out), output, "utf8");
+      console.log(`Wrote ${String(opts.out)} (${output.length} bytes)`);
+    } else {
+      console.log(output);
+    }
+    if (result.assumptions.length > 0) {
+      console.error("");
+      console.error("Model assumptions:");
+      for (const a of result.assumptions) console.error(`  - ${a}`);
+    }
+    if (result.parseFailed) {
+      console.warn("Model output could not be parsed \u2014 see the raw text via --format json.");
+    }
+  });
+  return cmd;
+}
+function splitFqn(fqn) {
+  const parts = fqn.split(".");
+  if (parts.length === 1) return { name: parts[0] };
+  if (parts.length === 2) return { schema: parts[0], name: parts[1] };
+  if (parts.length === 3) return { catalog: parts[0], schema: parts[1], name: parts[2] };
+  throw new Error(`Invalid --target "${fqn}": expected 1, 2, or 3 dot-separated parts.`);
+}
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+
+// src/commands/compare-profiles.ts
+var import_node_fs3 = require("fs");
+var import_commander6 = require("commander");
+var import_core5 = require("@ddt-tools/core");
+function compareProfilesCommand() {
+  const cmd = new import_commander6.Command("compare-profiles");
+  cmd.description("Manage saved compare profiles (.ddt/compare-profiles.json).");
+  cmd.command("list").description("List every saved profile.").option("--root <path>", "Project root. Default cwd.", process.cwd()).option("--json", "Emit JSON instead of a human table.").action(async (opts) => {
+    const store = new import_core5.compareProfiles.CompareProfilesStore({ root: String(opts.root) });
+    const all = await store.list();
+    if (opts.json) {
+      console.log(JSON.stringify(all, null, 2));
+      return;
+    }
+    if (all.length === 0) {
+      console.log("(no compare profiles saved yet)");
+      console.log(`  store: ${store.path}`);
+      return;
+    }
+    console.log(`${all.length} compare profile(s):`);
+    for (const p of all) {
+      console.log(`  ${p.id.padEnd(24)}  ${p.name}`);
+      console.log(`    source: ${p.source.kind}=${p.source.reference}`);
+      console.log(`    target: ${p.target.kind}=${p.target.reference}`);
+      console.log(`    mappings: ${p.mappings.length}    updated: ${p.updatedAt}`);
+    }
+  });
+  cmd.command("show").description("Show one profile by id.").argument("<id>", "Profile id (from `compare-profiles list`).").option("--root <path>", "Project root. Default cwd.", process.cwd()).option("--json", "Emit JSON instead of a human table.").action(async (id, opts) => {
+    const store = new import_core5.compareProfiles.CompareProfilesStore({ root: String(opts.root) });
+    const p = await store.get(String(id));
+    if (!p) {
+      console.error(
+        `No profile with id "${id}". Run \`ddt compare-profiles list\` to enumerate.`
+      );
+      process.exitCode = 1;
+      return;
+    }
+    if (opts.json) {
+      console.log(JSON.stringify(p, null, 2));
+      return;
+    }
+    console.log(`Profile: ${p.name} (${p.id})`);
+    if (p.description) console.log(`  ${p.description}`);
+    console.log(
+      `  source:  ${p.source.kind}=${p.source.reference}${p.source.catalog ? ` cat=${p.source.catalog}` : ""}${p.source.schema ? ` schema=${p.source.schema}` : ""}`
+    );
+    console.log(
+      `  target:  ${p.target.kind}=${p.target.reference}${p.target.catalog ? ` cat=${p.target.catalog}` : ""}${p.target.schema ? ` schema=${p.target.schema}` : ""}`
+    );
+    console.log(`  case-sensitive: ${p.caseSensitive ? "yes" : "no"}`);
+    console.log(`  rewrite-inside-strings: ${p.rewriteInsideStrings ? "yes" : "no"}`);
+    console.log(`  updatedAt: ${p.updatedAt}`);
+    if (p.mappings.length === 0) {
+      console.log("  mappings: (none \u2014 identity)");
+    } else {
+      console.log(`  mappings (${p.mappings.length}):`);
+      for (const m of p.mappings) console.log(`    ${m.source}  =>  ${m.target}`);
+    }
+  });
+  cmd.command("save").description("Upsert a profile from a JSON file or stdin.").option("--root <path>", "Project root. Default cwd.", process.cwd()).option("--json-file <path>", 'Path to a JSON file containing one profile. Use "-" for stdin.').action(async (opts) => {
+    if (!opts.jsonFile) {
+      throw new Error('--json-file is required (use a path or "-" for stdin).');
+    }
+    const raw = String(opts.jsonFile) === "-" ? await readStdin2() : await import_node_fs3.promises.readFile(String(opts.jsonFile), "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed?.id || !parsed?.name || !parsed?.source || !parsed?.target) {
+      throw new Error(
+        "Profile JSON must contain at minimum: id, name, source, target. mappings defaults to []."
+      );
+    }
+    const store = new import_core5.compareProfiles.CompareProfilesStore({ root: String(opts.root) });
+    const stamped = await store.upsert({ ...parsed, mappings: parsed.mappings ?? [] });
+    console.log(`Saved profile "${stamped.name}" (${stamped.id})`);
+    console.log(`  store: ${store.path}`);
+  });
+  cmd.command("remove").description("Delete one profile by id.").argument("<id>", "Profile id (from `compare-profiles list`).").option("--root <path>", "Project root. Default cwd.", process.cwd()).action(async (id, opts) => {
+    const store = new import_core5.compareProfiles.CompareProfilesStore({ root: String(opts.root) });
+    const removed = await store.remove(String(id));
+    if (removed) {
+      console.log(`Removed profile "${id}".`);
+    } else {
+      console.warn(`No profile with id "${id}" \u2014 nothing to remove.`);
+    }
+  });
+  cmd.command("preview").description(
+    "Preview which FQNs match between the profile's source and target. Local-only \u2014 no workspace round-trip."
+  ).argument("<id>", "Profile id (from `compare-profiles list`).").option("--root <path>", "Project root. Default cwd.", process.cwd()).option(
+    "--examples <n>",
+    "Max example FQNs to show per bucket in human output. Default 5.",
+    (v) => parseInt(v, 10),
+    5
+  ).option("--json", "Emit the full PreviewSummary as JSON.").action(async (id, opts) => {
+    const store = new import_core5.compareProfiles.CompareProfilesStore({ root: String(opts.root) });
+    const profile = await store.get(String(id));
+    if (!profile) {
+      console.error(
+        `No profile with id "${id}". Run \`ddt compare-profiles list\` to enumerate.`
+      );
+      process.exitCode = 1;
+      return;
+    }
+    const root = String(opts.root);
+    const source = await resolveEndpointFqns(profile.source, root);
+    const target = await resolveEndpointFqns(profile.target, root);
+    const summary = import_core5.compareProfiles.previewMatch({
+      source: source.fqns,
+      target: target.fqns,
+      mappings: profile.mappings,
+      ...profile.caseSensitive ? { caseSensitive: true } : {}
+    });
+    if (opts.json) {
+      console.log(
+        JSON.stringify(
+          {
+            profile: { id: profile.id, name: profile.name },
+            source: {
+              kind: profile.source.kind,
+              reference: profile.source.reference,
+              count: source.fqns.length
+            },
+            target: {
+              kind: profile.target.kind,
+              reference: profile.target.reference,
+              count: target.fqns.length
+            },
+            summary
+          },
+          null,
+          2
+        )
+      );
+      return;
+    }
+    console.log(`Preview: ${profile.name} (${profile.id})`);
+    console.log(
+      `  source (${profile.source.kind}=${profile.source.reference}): ${source.fqns.length} object(s)${source.note ? ` \u2014 ${source.note}` : ""}`
+    );
+    console.log(
+      `  target (${profile.target.kind}=${profile.target.reference}): ${target.fqns.length} object(s)${target.note ? ` \u2014 ${target.note}` : ""}`
+    );
+    console.log("");
+    console.log(`  matched:     ${summary.matchedCount}`);
+    console.log(`  source-only: ${summary.sourceOnlyCount}`);
+    console.log(`  target-only: ${summary.targetOnlyCount}`);
+    const exN = Math.max(0, Number(opts.examples));
+    printBucket("matched", summary.matched, exN);
+    printBucket("source-only", summary.sourceOnly, exN);
+    printBucket("target-only", summary.targetOnly, exN);
+    if (summary.matchedCount === 0 && (summary.sourceOnlyCount > 0 || summary.targetOnlyCount > 0)) {
+      console.warn("No FQNs matched \u2014 check the profile's scope and mapping rules.");
+    }
+  });
+  return cmd;
+}
+async function resolveEndpointFqns(endpoint, root) {
+  if (endpoint.kind === "connection") {
+    const cache = new import_core5.catalog.CatalogCache({ root, connection: endpoint.reference });
+    const snapshot = await cache.get();
+    if (snapshot.catalogs.length === 0) {
+      return {
+        fqns: [],
+        note: `empty catalog cache at ${cache.path} \u2014 run \`ddt catalog refresh --connection ${endpoint.reference}\` first`
+      };
+    }
+    return { fqns: fqnsFromSnapshot(snapshot, endpoint.catalog, endpoint.schema) };
+  }
+  if (endpoint.kind === "pac") {
+    const contents = await import_core5.pac.readPac(endpoint.reference);
+    return { fqns: fqnsFromObjects(contents.model, endpoint.catalog, endpoint.schema) };
+  }
+  const loaded = await (0, import_core5.loadProject)(endpoint.reference);
+  const model = await (0, import_core5.parseProjectModel)(loaded);
+  return { fqns: fqnsFromObjects(model, endpoint.catalog, endpoint.schema) };
+}
+function fqnsFromSnapshot(snapshot, catalogScope, schemaScope) {
+  const sameId = (a, b) => !!a && !!b && a.toUpperCase() === b.toUpperCase();
+  const out = [];
+  for (const cat of snapshot.catalogs) {
+    if (catalogScope && !sameId(cat.catalog, catalogScope)) continue;
+    for (const sc of cat.schemas) {
+      if (schemaScope && !sameId(sc.schema, schemaScope)) continue;
+      for (const obj of sc.objects) {
+        out.push({ database: obj.catalog, schema: obj.schema, name: obj.name });
+      }
+    }
+  }
+  return out;
+}
+function fqnsFromObjects(model, catalogScope, schemaScope) {
+  const sameId = (a, b) => !!a && !!b && a.toUpperCase() === b.toUpperCase();
+  const out = [];
+  for (const obj of model) {
+    if (catalogScope && !sameId(obj.fqn.database, catalogScope)) continue;
+    if (schemaScope && !sameId(obj.fqn.schema, schemaScope)) continue;
+    out.push(obj.fqn);
+  }
+  return out;
+}
+function printBucket(label, items, exampleN) {
+  if (items.length === 0) return;
+  console.log("");
+  console.log(
+    `  ${label} examples (showing ${Math.min(exampleN, items.length)} of ${items.length}):`
+  );
+  for (const fqn of items.slice(0, exampleN)) console.log(`    ${fqn}`);
+}
+async function readStdin2() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+
+// src/commands/explorer.ts
+var import_commander7 = require("commander");
+var import_core6 = require("@ddt-tools/core");
+function explorerCommand() {
+  const cmd = new import_commander7.Command("explorer");
+  cmd.description(
+    "ASCII tree dump of the cached catalog for a connection. Run `ddt catalog refresh` first to populate."
+  ).requiredOption("--connection <name>", "Connection profile name (the cache subfolder).").option("--root <path>", "Project root. Default cwd.", process.cwd()).option("--filter <query>", "Typeahead substring filter (case-insensitive).").option(
+    "--depth <n>",
+    "Truncate tree at depth N (0 = root only, 1 = +catalogs, 2 = +schemas, 3 = +object-groups, 4 = +objects). Default unlimited.",
+    (v) => parseInt(v, 10)
+  ).option("--json", "Emit tree as JSON instead of ASCII.").action(async (opts) => {
+    const cache = new import_core6.catalog.CatalogCache({
+      root: String(opts.root),
+      connection: String(opts.connection)
+    });
+    const snapshot = await cache.get();
+    let tree = import_core6.objectExplorer.treeForSnapshot(snapshot);
+    if (opts.filter) tree = import_core6.objectExplorer.filterTree(tree, String(opts.filter));
+    if (typeof opts.depth === "number") tree = import_core6.objectExplorer.truncateTree(tree, opts.depth);
+    if (snapshot.catalogs.length === 0) {
+      console.warn(`Catalog cache is empty for connection "${opts.connection}".`);
+      console.warn(`  Cache file: ${cache.path}`);
+      console.warn(`  Run \`ddt catalog refresh --connection ${opts.connection}\` to populate.`);
+      return;
+    }
+    if (opts.json) {
+      console.log(JSON.stringify(tree, null, 2));
+      return;
+    }
+    renderAsciiTree(tree);
+  });
+  return cmd;
+}
+function renderAsciiTree(root) {
+  const desc = root.description ? `  (${root.description})` : "";
+  console.log(`${root.label}${desc}`);
+  const children = root.children ?? [];
+  for (let i = 0; i < children.length; i++) {
+    renderChild(children[i], "", i === children.length - 1);
+  }
+}
+function renderChild(node, prefix, isLast) {
+  const connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+  const desc = node.description ? `  (${node.description})` : "";
+  console.log(`${prefix}${connector}${node.label}${desc}`);
+  const children = node.children ?? [];
+  const childPrefix = prefix + (isLast ? "    " : "\u2502   ");
+  for (let i = 0; i < children.length; i++) {
+    renderChild(children[i], childPrefix, i === children.length - 1);
+  }
+}
+
+// src/commands/catalog.ts
+var import_commander8 = require("commander");
+var import_core7 = require("@ddt-tools/core");
+var BUILTIN_CATALOGS = /* @__PURE__ */ new Set(["system", "samples", "__databricks_internal"]);
+function catalogCommand() {
+  const cmd = new import_commander8.Command("catalog");
+  cmd.description(
+    "Manage the per-connection catalog cache used by the Object Explorer + EE2 intellisense."
+  );
+  cmd.command("refresh").description("Open the connection, scan every (non-builtin) catalog, write the catalog cache.").requiredOption("-c, --connection <name>", "Connection profile name.").option("--root <path>", "Project root. Default cwd.", process.cwd()).option("--catalogs <csv>", "Comma-separated list. Default: every non-builtin catalog.").option("--include-builtins", "Include system / samples / __databricks_internal.", false).option(
+    "--concurrency <n>",
+    "Bounded-concurrency cap for the bulk-scan pool. Default 10.",
+    "10"
+  ).option("--no-fingerprint-skip", "Force a full scan even when fingerprints are unchanged.").action(async (opts) => {
+    const profile = await (0, import_core7.getProfile)(String(opts.connection));
+    const conn = (0, import_core7.createConnection)(profile);
+    const cache = new import_core7.catalog.CatalogCache({
+      root: String(opts.root),
+      connection: profile.name
+    });
+    console.log(`Connecting to ${profile.auth.host}\u2026`);
+    await conn.connect();
+    try {
+      const cats = await resolveCatalogs(conn, opts);
+      if (cats.length === 0) {
+        console.warn("No catalogs to scan. Pass --catalogs or --include-builtins.");
+        return;
+      }
+      console.log(
+        `Scanning ${cats.length} catalog(s) with concurrency ${Number(opts.concurrency)}.`
+      );
+      const cached = await cache.get();
+      const cachedByCat = new Map(cached.catalogs.map((c) => [c.catalog, c]));
+      const concurrency = Math.max(1, Number(opts.concurrency) || 10);
+      const fingerprintSkip = opts.fingerprintSkip !== false;
+      const { results, errors } = await import_core7.catalog.mapPool(
+        cats,
+        async (cat) => {
+          let freshFingerprint = null;
+          try {
+            const fpRes = await conn.query(
+              import_core7.catalog.fingerprintSqlForCatalog(cat)
+            );
+            freshFingerprint = import_core7.catalog.parseFingerprintRow(fpRes.rows);
+          } catch (err) {
+            console.warn(
+              `fingerprint(${cat}) failed; falling through to full scan: ${err.message}`
+            );
+          }
+          const cachedCat = cachedByCat.get(cat);
+          if (fingerprintSkip && cachedCat && cachedCat.fingerprint != null && freshFingerprint != null && import_core7.catalog.isFresh(cachedCat.fingerprint, freshFingerprint)) {
+            console.log(`  ${cat}: fresh; reusing cache`);
+            return {
+              catalog: cat,
+              fingerprint: cachedCat.fingerprint,
+              schemas: cachedCat.schemas
+            };
+          }
+          const scanRes = await conn.query(import_core7.catalog.bulkScanSqlForCatalog(cat));
+          const schemas = import_core7.catalog.parseBulkScanRows(cat, scanRes.rows);
+          const fingerprint = freshFingerprint ?? null;
+          console.log(
+            `  ${cat}: ${schemas.length} schemas / ${schemas.reduce((sum, s) => sum + s.objects.length, 0)} objects`
+          );
+          return { catalog: cat, fingerprint, schemas };
+        },
+        { concurrency }
+      );
+      for (const e of errors) {
+        console.warn(`scan failed for "${cats[e.index]}": ${e.error.message}`);
+      }
+      const snapshot = import_core7.catalog.refreshFingerprints({
+        version: import_core7.catalog.CATALOG_SNAPSHOT_VERSION,
+        connection: profile.name,
+        snapshotAt: (/* @__PURE__ */ new Date()).toISOString(),
+        fingerprint: null,
+        catalogs: results.filter((r) => !!r)
+      });
+      await cache.set(snapshot);
+      console.log(`Wrote ${snapshot.catalogs.length} catalogs to ${cache.path}`);
+    } finally {
+      await conn.disconnect();
+    }
+  });
+  cmd.command("show").description("Pretty-print or JSON-dump the cached snapshot for a connection.").requiredOption("-c, --connection <name>", "Connection profile name.").option("--root <path>", "Project root. Default cwd.", process.cwd()).option("--json", "Emit JSON instead of summary.").action(async (opts) => {
+    const cache = new import_core7.catalog.CatalogCache({
+      root: String(opts.root),
+      connection: String(opts.connection)
+    });
+    const snapshot = await cache.get();
+    if (opts.json) {
+      console.log(JSON.stringify(snapshot, null, 2));
+      return;
+    }
+    if (snapshot.catalogs.length === 0) {
+      console.warn(`Catalog cache is empty for "${opts.connection}".`);
+      console.warn(`  Cache file: ${cache.path}`);
+      console.warn(`  Run \`ddt catalog refresh --connection ${opts.connection}\` to populate.`);
+      return;
+    }
+    console.log(`Snapshot for "${snapshot.connection}" \u2014 ${snapshot.snapshotAt}`);
+    console.log(
+      `  Top-level fingerprint: ${snapshot.fingerprint != null ? new Date(snapshot.fingerprint).toISOString() : "(none)"}`
+    );
+    for (const cat of snapshot.catalogs) {
+      const objCount = cat.schemas.reduce((sum, s) => sum + s.objects.length, 0);
+      console.log(
+        `  ${cat.catalog.padEnd(32)}  ${cat.schemas.length} schemas / ${objCount} objects`
+      );
+    }
+  });
+  cmd.command("clear").description("Delete the cached snapshot for a connection.").requiredOption("-c, --connection <name>", "Connection profile name.").option("--root <path>", "Project root. Default cwd.", process.cwd()).action(async (opts) => {
+    const cache = new import_core7.catalog.CatalogCache({
+      root: String(opts.root),
+      connection: String(opts.connection)
+    });
+    await cache.clear();
+    console.log(`Cleared cache for "${opts.connection}".`);
+    console.log(`  was: ${cache.path}`);
+  });
+  return cmd;
+}
+async function resolveCatalogs(conn, opts) {
+  if (opts.catalogs) {
+    return String(opts.catalogs).split(",").map((s) => s.trim()).filter(Boolean);
+  }
+  const res = await conn.query("SHOW CATALOGS");
+  const names = res.rows.map((r) => String(r.catalog ?? r.catalog_name ?? r.CATALOG ?? r.CATALOG_NAME ?? "")).filter(Boolean);
+  if (opts.includeBuiltins) return names;
+  return names.filter((n) => !BUILTIN_CATALOGS.has(n.toLowerCase()));
+}
+
+// src/commands/exec.ts
+var import_commander9 = require("commander");
+var import_node_fs4 = require("fs");
+var import_connection = require("@ddt-tools/core/connection");
+var import_core8 = require("@ddt-tools/core");
+var PROD_PATTERN = /\bprod(uction)?\b/i;
+function isProductionProfile(name) {
+  return PROD_PATTERN.test(name);
+}
+async function runOnProfile(execFn, profile, sql, timeoutMs) {
+  const start = Date.now();
+  try {
+    const res = await execFn(profile, sql, timeoutMs);
+    return { ...res, profile, durationMs: Date.now() - start };
+  } catch (err) {
+    return {
+      profile,
+      status: "error",
+      durationMs: Date.now() - start,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+function renderText(results) {
+  const lines = [];
+  for (const r of results) {
+    if (r.status === "success") {
+      const rows = r.rowsAffected !== void 0 ? ` (${r.rowsAffected} rows)` : "";
+      lines.push(`  ${r.profile}: \u2713${rows} \u2014 ${(r.durationMs / 1e3).toFixed(1)}s`);
+    } else {
+      lines.push(`  ${r.profile}: \u2717 ${r.error ?? "unknown error"}`);
+    }
+  }
+  const total = results.length;
+  const succeeded = results.filter((r) => r.status === "success").length;
+  lines.push(`
+${succeeded}/${total} profiles succeeded.`);
+  return lines.join("\n");
+}
+async function defaultExecFn(profile, sql, timeoutMs) {
+  const profileObj = await (0, import_connection.getProfile)(profile);
+  const conn = (0, import_connection.createConnection)(profileObj);
+  await conn.connect();
+  try {
+    const timeoutSeconds = Math.max(1, Math.ceil(timeoutMs / 1e3));
+    const runner = {
+      executeStatement: async (statement) => {
+        const result2 = await conn.query(statement, { timeoutSeconds });
+        return {
+          rows: result2.rows,
+          durationMs: result2.durationMs
+        };
+      }
+    };
+    const result = await import_core8.queryExecution.executeStatements(sql, runner, {
+      failFast: false,
+      splitOptions: { dialect: "databricks" },
+      toolName: "ddt"
+    });
+    const firstError = result.statements.find((s) => s.error);
+    if (firstError && firstError.error) {
+      throw new Error(firstError.error.message);
+    }
+    const rowsAffected = result.statements.reduce((acc, s) => acc + (s.rowCount ?? 0), 0);
+    return { status: "success", rowsAffected };
+  } finally {
+    await conn.disconnect().catch(() => {
+    });
+  }
+}
+function execCommand(execFn = defaultExecFn) {
+  const cmd = new import_commander9.Command("exec");
+  cmd.description("Run a SQL script on one or more connection profiles in parallel.").argument("<file>", "Path to the .sql file to execute.").requiredOption("--profiles <list>", "Comma-separated connection profile names.").option("--yes", "Confirm execution against production profiles without prompting.").option("--format <fmt>", "text | json (default text).", "text").option("--timeout <ms>", "Per-profile timeout in milliseconds.", "30000").action(async (file, opts) => {
+    const profiles = opts.profiles.split(",").map((p) => p.trim()).filter(Boolean);
+    if (profiles.length === 0) throw new Error("--profiles must list at least one profile.");
+    const prodProfiles = profiles.filter(isProductionProfile);
+    if (prodProfiles.length > 0 && !opts.yes) {
+      throw new Error(
+        `Profile(s) look like production: ${prodProfiles.join(", ")}. Pass --yes to confirm.`
+      );
+    }
+    let sql;
+    try {
+      sql = await import_node_fs4.promises.readFile(file, "utf8");
+    } catch {
+      throw new Error(`Cannot read file: ${file}`);
+    }
+    if (!sql.trim()) throw new Error(`File is empty: ${file}`);
+    const timeoutMs = parseInt(String(opts.timeout ?? "30000"), 10);
+    const results = await Promise.all(
+      profiles.map((p) => runOnProfile(execFn, p, sql, timeoutMs))
+    );
+    const fmt = String(opts.format ?? "text").toLowerCase();
+    if (fmt === "json") {
+      const failed = results.filter((r) => r.status === "error").length;
+      process.stdout.write(
+        JSON.stringify(
+          {
+            results,
+            summary: {
+              total: results.length,
+              succeeded: results.length - failed,
+              failed
+            }
+          },
+          null,
+          2
+        ) + "\n"
+      );
+      return;
+    }
+    if (fmt !== "text") throw new Error(`Unknown --format: ${opts.format}. Use text | json.`);
+    process.stdout.write(renderText(results) + "\n");
+  });
+  return cmd;
+}
+
+// src/commands/search.ts
+var import_commander10 = require("commander");
+var import_node_fs5 = require("fs");
+var import_node_os = __toESM(require("os"), 1);
+var import_node_path = __toESM(require("path"), 1);
+var import_core9 = require("@ddt-tools/core");
+function buildDriftReport(results) {
+  const allFqns = /* @__PURE__ */ new Set();
+  const byFqn = /* @__PURE__ */ new Map();
+  for (const r of results) {
+    if (r.error) continue;
+    for (const m of r.matches) {
+      allFqns.add(m.fqn);
+      if (!byFqn.has(m.fqn)) byFqn.set(m.fqn, /* @__PURE__ */ new Set());
+      byFqn.get(m.fqn).add(r.profile);
+    }
+  }
+  const successProfiles = results.filter((r) => !r.error).map((r) => r.profile);
+  const driftLines = [];
+  for (const fqn of allFqns) {
+    const present = byFqn.get(fqn);
+    if (present.size < successProfiles.length) {
+      const absent = successProfiles.filter((p) => !present.has(p));
+      driftLines.push(
+        `  DRIFT  ${fqn}  [present: ${[...present].join(", ")}  absent: ${absent.join(", ")}]`
+      );
+    }
+  }
+  return driftLines.join("\n");
+}
+function renderText2(results, showDrift) {
+  const lines = [];
+  for (const r of results) {
+    if (r.error) {
+      lines.push(`[${r.profile}] ERROR: ${r.error}`);
+      continue;
+    }
+    if (r.matches.length === 0) {
+      lines.push(`[${r.profile}] no matches`);
+    } else {
+      for (const m of r.matches) {
+        lines.push(`[${r.profile}] ${m.fqn}  (${m.objectType})`);
+      }
+    }
+  }
+  if (showDrift) {
+    const drift = buildDriftReport(results);
+    if (drift) {
+      lines.push("");
+      lines.push("--- Drift detected ---");
+      lines.push(drift);
+    }
+  }
+  return lines.join("\n");
+}
+async function loadProfileNames(profilesOpt, profilesDir) {
+  if (profilesOpt.toLowerCase() !== "all") {
+    return profilesOpt.split(",").map((p) => p.trim()).filter(Boolean);
+  }
+  try {
+    const entries = await import_node_fs5.promises.readdir(profilesDir);
+    return entries.filter((e) => e.endsWith(".json") || e.endsWith(".toml")).map((e) => import_node_path.default.basename(e, import_node_path.default.extname(e)));
+  } catch {
+    return [];
+  }
+}
+async function defaultSearchFn(profile, pattern, opts) {
+  const root = opts.root ?? process.cwd();
+  const cache = new import_core9.catalog.CatalogCache({ root, connection: profile });
+  const snapshot = await cache.get();
+  if (snapshot.catalogs.length === 0) {
+    throw new Error(
+      `No catalog cache for profile "${profile}" at ${cache.path}. Run \`ddt catalog refresh --connection ${profile} --root ${root}\` or \`ddt extract --connection ${profile} --output ${root} --write-catalog-cache\` first.`
+    );
+  }
+  const needle = pattern.toLowerCase();
+  const typeFilter = opts.objectType ? opts.objectType.toUpperCase() : void 0;
+  const matches = [];
+  for (const cat of snapshot.catalogs) {
+    for (const schema of cat.schemas) {
+      for (const obj of schema.objects) {
+        if (typeFilter && obj.objectType !== typeFilter) continue;
+        const name = obj.name.toLowerCase();
+        const hit = opts.exact ? name === needle : name.includes(needle);
+        if (hit) {
+          matches.push({
+            profile,
+            fqn: `${obj.catalog}.${obj.schema}.${obj.name}`,
+            objectType: obj.objectType
+          });
+        }
+      }
+    }
+  }
+  return matches;
+}
+function searchCommand(searchFn = defaultSearchFn) {
+  const cmd = new import_commander10.Command("search");
+  cmd.description("Find objects matching a name pattern across one or more connection profiles.").argument("<pattern>", "Name pattern to search for (case-insensitive substring).").requiredOption(
+    "--profiles <list|all>",
+    'Comma-separated profile names, or "all" to scan every configured profile.'
+  ).option("--exact", "Exact name match instead of substring.", false).option("--type <objectType>", "Filter results to a specific object type (e.g. TABLE, VIEW).").option("--format <fmt>", "text | json (default text).", "text").option(
+    "--profiles-dir <dir>",
+    "Directory to scan when --profiles all is used.",
+    import_node_path.default.join(import_node_os.default.homedir(), ".ddt", "connections")
+  ).option(
+    "--root <dir>",
+    "Project / cache root containing the .ddt/cache directory. Default: cwd.",
+    process.cwd()
+  ).option("--no-drift", "Suppress the drift section in text output.").action(async (pattern, opts) => {
+    const profiles = await loadProfileNames(opts.profiles, opts.profilesDir);
+    if (profiles.length === 0) {
+      throw new Error(
+        opts.profiles.toLowerCase() === "all" ? `No profiles found in ${opts.profilesDir}. Run \`ddt connection add\` first.` : "--profiles must list at least one profile."
+      );
+    }
+    const results = await Promise.all(
+      profiles.map(async (p) => {
+        try {
+          const matches = await searchFn(p, pattern, {
+            exact: opts.exact,
+            objectType: opts.type,
+            root: opts.root
+          });
+          return { profile: p, matches };
+        } catch (err) {
+          return {
+            profile: p,
+            matches: [],
+            error: err instanceof Error ? err.message : String(err)
+          };
+        }
+      })
+    );
+    const fmt = String(opts.format ?? "text").toLowerCase();
+    if (fmt === "json") {
+      process.stdout.write(JSON.stringify(results, null, 2) + "\n");
+      return;
+    }
+    if (fmt !== "text") throw new Error(`Unknown --format: ${opts.format}. Use text | json.`);
+    const text = renderText2(results, opts.drift !== false);
+    process.stdout.write(text ? text + "\n" : "No results.\n");
+  });
+  return cmd;
+}
+
+// src/commands/query-log.ts
+var import_commander11 = require("commander");
+var import_node_fs6 = require("fs");
+var import_node_os2 = __toESM(require("os"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
+var import_core10 = require("@ddt-tools/core");
+var DEFAULT_STORE = import_node_path2.default.join(import_node_os2.default.homedir(), ".ddt", "query-log.json");
+async function loadStore(storePath) {
+  try {
+    const raw = await import_node_fs6.promises.readFile(storePath, "utf8");
+    return import_core10.queryLog.QueryLogStore.deserialize(JSON.parse(raw));
+  } catch {
+    return new import_core10.queryLog.QueryLogStore();
+  }
+}
+async function saveStore(storePath, store) {
+  await import_node_fs6.promises.mkdir(import_node_path2.default.dirname(storePath), { recursive: true });
+  await import_node_fs6.promises.writeFile(storePath, JSON.stringify(store.serialize(), null, 2), "utf8");
+}
+function queryLogCommand() {
+  const cmd = new import_commander11.Command("query-log");
+  cmd.description("Browse and manage the local query log from the EE3 query window (AUTH.5).");
+  cmd.command("list").description("List recent query log entries (newest first).").option("--profile <p>", "Filter to a specific connection profile.").option("--limit <n>", "Maximum entries to show (default 100).", "100").option("--format <fmt>", "text | json (default text).", "text").option("--store <path>", "Path to the query log JSON file.", DEFAULT_STORE).action(async (opts) => {
+    const store = await loadStore(opts.store);
+    const entries = store.listEntries({
+      profile: opts.profile,
+      limit: parseInt(String(opts.limit ?? "100"), 10)
+    });
+    const fmt = String(opts.format ?? "text").toLowerCase();
+    if (fmt === "json") {
+      process.stdout.write(JSON.stringify(entries, null, 2) + "\n");
+      return;
+    }
+    if (entries.length === 0) {
+      process.stdout.write("No query log entries.\n");
+      return;
+    }
+    for (const e of entries) {
+      const when = e.executedAt.slice(0, 19).replace("T", " ");
+      const dur = e.durationMs !== void 0 ? ` ${e.durationMs}ms` : "";
+      const rows = e.rowCount !== void 0 ? ` ${e.rowCount} rows` : "";
+      const status = e.status === "error" ? " \u2717" : " \u2713";
+      const sql = e.sql.replace(/\s+/g, " ").slice(0, 80);
+      process.stdout.write(`[${e.id}] ${when} [${e.profile}]${status}${dur}${rows}  ${sql}
+`);
+    }
+  });
+  cmd.command("show <id>").description("Show a single query log entry by id.").option("--format <fmt>", "text | json | sql (default text).", "text").option("--store <path>", "Path to the query log JSON file.", DEFAULT_STORE).action(async (id, opts) => {
+    const store = await loadStore(opts.store);
+    const entry = store.getEntry(id);
+    if (!entry) throw new Error(`No entry with id '${id}'.`);
+    const fmt = String(opts.format ?? "text").toLowerCase();
+    if (fmt === "sql") {
+      process.stdout.write(entry.sql + "\n");
+      return;
+    }
+    if (fmt === "json") {
+      process.stdout.write(JSON.stringify(entry, null, 2) + "\n");
+      return;
+    }
+    process.stdout.write(`id: ${entry.id}
+`);
+    process.stdout.write(`profile: ${entry.profile}
+`);
+    process.stdout.write(`executed: ${entry.executedAt}
+`);
+    process.stdout.write(`status: ${entry.status}
+`);
+    if (entry.durationMs !== void 0) process.stdout.write(`duration: ${entry.durationMs}ms
+`);
+    if (entry.rowCount !== void 0) process.stdout.write(`rows: ${entry.rowCount}
+`);
+    if (entry.error) process.stdout.write(`error: ${entry.error}
+`);
+    process.stdout.write(`
+${entry.sql}
+`);
+  });
+  cmd.command("add <sql>").description("Manually append a query to the log (used by EE3 and for testing).").requiredOption("--profile <p>", "Connection profile the query was run against.").option("--status <s>", "success | error (default success).", "success").option("--store <path>", "Path to the query log JSON file.", DEFAULT_STORE).action(async (sql, opts) => {
+    if (opts.status !== "success" && opts.status !== "error") {
+      throw new Error(`--status must be success or error, got: ${opts.status}`);
+    }
+    const store = await loadStore(opts.store);
+    const entry = store.appendEntry({
+      profile: opts.profile,
+      sql,
+      executedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      status: opts.status
+    });
+    await saveStore(opts.store, store);
+    process.stdout.write(`Added entry ${entry.id}.
+`);
+  });
+  cmd.command("clear").description("Remove query log entries.").option("--profile <p>", "Remove only entries for this profile (omit for all).").option("--yes", "Skip confirmation prompt.").option("--store <path>", "Path to the query log JSON file.", DEFAULT_STORE).action(async (opts) => {
+    if (!opts.yes) {
+      const target = opts.profile ? `profile '${opts.profile}'` : "all profiles";
+      throw new Error(`Pass --yes to confirm clearing the query log for ${target}.`);
+    }
+    const store = await loadStore(opts.store);
+    const removed = store.clearEntries(opts.profile);
+    await saveStore(opts.store, store);
+    process.stdout.write(`Cleared ${removed} entries.
+`);
+  });
+  return cmd;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  catalogCommand,
+  compareProfilesCommand,
+  connectionCommand,
+  execCommand,
+  explorerCommand,
+  queryLogCommand,
+  saferAlternativeCommand,
+  safetyCommand,
+  scaffoldCommand,
+  searchCommand,
+  sketchCommand
+});
+//# sourceMappingURL=index.cjs.map