@sdt-tools/cli 0.2.0 → 0.2.6

package/dist/cost-estimate-TJDDH6TO.js

@@ -0,0 +1,328 @@
+import {
+  attachExplainFlag,
+  runExplain
+} from "./chunk-ZWY4ZRHL.js";
+import "./chunk-VM2H4LAO.js";
+import "./chunk-DGUM43GV.js";
+
+// src/commands/cost-estimate.ts
+import { promises as fs } from "fs";
+import path from "path";
+import { Command } from "commander";
+function costEstimateCommand() {
+  const cmd = new Command("cost-estimate");
+  cmd.description("Heuristic Snowflake-credit estimate for a generated migration script.").requiredOption(
+    "--script <path>",
+    "Path to a generated migration script (.sql) from `sdt publish --out`."
+  ).option(
+    "--warehouse-size <size>",
+    "Target warehouse size for the cost ladder: XS | S | M | L | XL | 2XL | 3XL | 4XL.",
+    "S"
+  ).option("--format <fmt>", "table | json | markdown. Default table.", "table").option("-o, --out <path>", "Write output to file. Defaults to stdout.").option(
+    "--calibrate-from <path>",
+    "AI Phase 6 calibration: a JSON file of QueryHistoryEntry[] from prior deploys. Each historic statement is classified against the same cost-classes; classes with \u22653 samples adopt empirical min/max duration in place of the heuristic range."
+  ).action(
+    async (opts) => {
+      const sql = await fs.readFile(path.resolve(String(opts.script)), "utf8");
+      const wh = String(opts.warehouseSize ?? "S").toUpperCase();
+      const wantedSizes = [
+        "XS",
+        "S",
+        "M",
+        "L",
+        "XL",
+        "2XL",
+        "3XL",
+        "4XL"
+      ];
+      if (!wantedSizes.includes(wh)) {
+        throw new Error(
+          `Unknown --warehouse-size: ${wh}. Use one of ${wantedSizes.join(" | ")}.`
+        );
+      }
+      let calibration;
+      if (opts.calibrateFrom) {
+        const histRaw = await fs.readFile(path.resolve(String(opts.calibrateFrom)), "utf8");
+        const parsed = JSON.parse(histRaw);
+        const entries = Array.isArray(parsed) ? parsed : Array.isArray(parsed.entries) ? parsed.entries : [];
+        calibration = buildCalibration(entries);
+      }
+      const report = estimateCost(sql, wh, calibration);
+      const fmt = String(opts.format ?? "table").toLowerCase();
+      let payload;
+      if (fmt === "json") {
+        payload = JSON.stringify(report, null, 2);
+      } else if (fmt === "markdown") {
+        payload = renderMarkdown(report);
+      } else {
+        payload = renderTable(report);
+      }
+      if (opts.out) {
+        const p = path.resolve(String(opts.out));
+        await fs.mkdir(path.dirname(p), { recursive: true });
+        await fs.writeFile(p, payload + (payload.endsWith("\n") ? "" : "\n"), "utf8");
+        console.error(`Wrote ${p}.`);
+      } else {
+        process.stdout.write(payload + (payload.endsWith("\n") ? "" : "\n"));
+      }
+      await runExplain(
+        {
+          feature: "cost-estimate.explain",
+          systemPrompt: "You are a Snowflake cost engineer. Walk the team through this cost estimate: what is the dominant cost driver, what does the range mean in practice, and what knobs (warehouse size, sequencing, off-peak timing) would meaningfully reduce it."
+        },
+        opts,
+        () => `Cost estimate (JSON) follows:
+
+${JSON.stringify(report, null, 2)}
+
+Narrate this for a teammate.`
+      );
+    }
+  );
+  attachExplainFlag(cmd);
+  return cmd;
+}
+var CREDITS_PER_HOUR = {
+  XS: 1,
+  S: 2,
+  M: 4,
+  L: 8,
+  XL: 16,
+  "2XL": 32,
+  "3XL": 64,
+  "4XL": 128
+};
+var COST_CLASSES = [
+  {
+    id: "table-rebuild",
+    description: "CREATE OR REPLACE TABLE or CTAS \u2014 rewrites the entire table",
+    minSeconds: 30,
+    maxSeconds: 1800,
+    test: (s) => /CREATE\s+(?:OR\s+REPLACE\s+)?TABLE\s+.+\s+AS\s+SELECT/i.test(s) || /CREATE\s+OR\s+REPLACE\s+TABLE\b/i.test(s)
+  },
+  {
+    id: "add-column",
+    description: "ALTER TABLE ADD COLUMN \u2014 metadata-only, no scan",
+    minSeconds: 1,
+    maxSeconds: 5,
+    test: (s) => /ALTER\s+TABLE\b.*\bADD\s+COLUMN\b/i.test(s)
+  },
+  {
+    id: "drop-column",
+    description: "ALTER TABLE DROP COLUMN \u2014 metadata-only",
+    minSeconds: 1,
+    maxSeconds: 5,
+    test: (s) => /ALTER\s+TABLE\b.*\bDROP\s+COLUMN\b/i.test(s)
+  },
+  {
+    id: "alter-type-narrowing",
+    description: "ALTER COLUMN TYPE (narrowing) \u2014 full data scan + rewrite",
+    minSeconds: 30,
+    maxSeconds: 600,
+    test: (s) => /ALTER\s+TABLE\b.*\bALTER\s+COLUMN\b.*\bSET\s+DATA\s+TYPE\b/i.test(s)
+  },
+  {
+    id: "create-view",
+    description: "CREATE OR REPLACE VIEW \u2014 metadata-only",
+    minSeconds: 1,
+    maxSeconds: 3,
+    test: (s) => /CREATE\s+(?:OR\s+REPLACE\s+)?VIEW\b/i.test(s)
+  },
+  {
+    id: "create-mv",
+    description: "CREATE MATERIALIZED VIEW \u2014 initial population can be costly",
+    minSeconds: 60,
+    maxSeconds: 3600,
+    test: (s) => /CREATE\s+(?:OR\s+REPLACE\s+)?MATERIALIZED\s+VIEW\b/i.test(s)
+  },
+  {
+    id: "create-dynamic-table",
+    description: "CREATE DYNAMIC TABLE \u2014 initial materialisation cost",
+    minSeconds: 60,
+    maxSeconds: 1800,
+    test: (s) => /CREATE\s+(?:OR\s+REPLACE\s+)?DYNAMIC\s+TABLE\b/i.test(s)
+  },
+  {
+    id: "create-stream",
+    description: "CREATE STREAM \u2014 metadata-only",
+    minSeconds: 1,
+    maxSeconds: 3,
+    test: (s) => /CREATE\s+(?:OR\s+REPLACE\s+)?STREAM\b/i.test(s)
+  },
+  {
+    id: "create-task",
+    description: "CREATE TASK \u2014 metadata-only",
+    minSeconds: 1,
+    maxSeconds: 3,
+    test: (s) => /CREATE\s+(?:OR\s+REPLACE\s+)?TASK\b/i.test(s)
+  },
+  {
+    id: "create-warehouse",
+    description: "CREATE WAREHOUSE \u2014 metadata; cost depends on usage",
+    minSeconds: 1,
+    maxSeconds: 5,
+    test: (s) => /CREATE\s+(?:OR\s+REPLACE\s+)?WAREHOUSE\b/i.test(s)
+  },
+  {
+    id: "pre-deploy-clone",
+    description: "CREATE DATABASE ... CLONE \u2014 Snowflake zero-copy clone (~instant)",
+    minSeconds: 1,
+    maxSeconds: 10,
+    test: (s) => /CREATE\s+(?:OR\s+REPLACE\s+)?DATABASE\s+\S+\s+CLONE\b/i.test(s)
+  },
+  {
+    id: "drop",
+    description: "DROP statement \u2014 metadata-only",
+    minSeconds: 1,
+    maxSeconds: 3,
+    test: (s) => /^\s*DROP\s+/i.test(s)
+  },
+  {
+    id: "grant",
+    description: "GRANT / REVOKE \u2014 metadata-only",
+    minSeconds: 1,
+    maxSeconds: 2,
+    test: (s) => /^\s*(?:GRANT|REVOKE)\s+/i.test(s)
+  },
+  {
+    id: "comment",
+    description: "COMMENT-only statement (-- \u2026 no DDL) \u2014 free",
+    minSeconds: 0,
+    maxSeconds: 0,
+    test: (s) => s.replace(/--[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "").trim().length === 0
+  }
+];
+function buildCalibration(entries) {
+  const samples = /* @__PURE__ */ new Map();
+  for (const e of entries) {
+    const sql = typeof e.sqlText === "string" ? e.sqlText : "";
+    const dur = typeof e.durationMs === "number" ? e.durationMs : NaN;
+    if (!sql || !isFinite(dur) || dur <= 0) continue;
+    const matched = COST_CLASSES.find((c) => c.test(sql));
+    if (!matched) continue;
+    const arr = samples.get(matched.id) ?? [];
+    arr.push(dur / 1e3);
+    samples.set(matched.id, arr);
+  }
+  const perClass = {};
+  for (const [id, durs] of samples) {
+    if (durs.length < 3) continue;
+    durs.sort((a, b) => a - b);
+    perClass[id] = {
+      sampleSize: durs.length,
+      minSeconds: Math.max(1, Math.round(durs[0])),
+      maxSeconds: Math.max(1, Math.round(durs[durs.length - 1]))
+    };
+  }
+  return { perClass };
+}
+function estimateCost(sql, warehouseSize, calibration) {
+  const statements = splitStatements(sql);
+  const classCounts = /* @__PURE__ */ new Map();
+  let classifiedStatements = 0;
+  let unknownStatements = 0;
+  for (const stmt of statements) {
+    const matched = COST_CLASSES.find((c) => c.test(stmt));
+    if (matched) {
+      classCounts.set(matched.id, (classCounts.get(matched.id) ?? 0) + 1);
+      classifiedStatements++;
+    } else if (stmt.trim().length > 0) {
+      unknownStatements++;
+    }
+  }
+  const creditsPerHour = CREDITS_PER_HOUR[warehouseSize];
+  const perClass = COST_CLASSES.filter((c) => (classCounts.get(c.id) ?? 0) > 0).map((c) => {
+    const count = classCounts.get(c.id) ?? 0;
+    const cal = calibration?.perClass[c.id];
+    const minSecondsPerStmt = cal ? cal.minSeconds : c.minSeconds;
+    const maxSecondsPerStmt = cal ? cal.maxSeconds : c.maxSeconds;
+    const minSeconds = minSecondsPerStmt * count;
+    const maxSeconds = maxSecondsPerStmt * count;
+    return {
+      id: c.id,
+      description: c.description,
+      count,
+      minSeconds,
+      maxSeconds,
+      minCredits: minSeconds / 3600 * creditsPerHour,
+      maxCredits: maxSeconds / 3600 * creditsPerHour,
+      ...cal ? { calibratedFromSamples: cal.sampleSize } : {}
+    };
+  });
+  const totals = perClass.reduce(
+    (acc, c) => ({
+      minSeconds: acc.minSeconds + c.minSeconds,
+      maxSeconds: acc.maxSeconds + c.maxSeconds,
+      minCredits: acc.minCredits + c.minCredits,
+      maxCredits: acc.maxCredits + c.maxCredits
+    }),
+    { minSeconds: 0, maxSeconds: 0, minCredits: 0, maxCredits: 0 }
+  );
+  return {
+    warehouseSize,
+    creditsPerHour,
+    totalStatements: statements.length,
+    classifiedStatements,
+    unknownStatements,
+    perClass,
+    totals
+  };
+}
+function splitStatements(sql) {
+  return sql.replace(/\/\*[\s\S]*?\*\//g, "").split(/;\s*$/m).map((s) => s.trim()).filter(Boolean);
+}
+function renderTable(r) {
+  const lines = [];
+  lines.push(`Cost estimate \u2014 warehouse=${r.warehouseSize} (${r.creditsPerHour} credit/hour)`);
+  lines.push("");
+  lines.push(
+    `  Statements: ${r.totalStatements} (${r.classifiedStatements} classified, ${r.unknownStatements} unknown).`
+  );
+  lines.push("");
+  const idW = Math.max(20, ...r.perClass.map((c) => c.id.length));
+  for (const c of r.perClass) {
+    lines.push(
+      `  ${c.id.padEnd(idW)}  \xD7${String(c.count).padStart(4)}  \u2248 ${c.minCredits.toFixed(3)} \u2013 ${c.maxCredits.toFixed(3)} credit`
+    );
+  }
+  lines.push("");
+  lines.push(
+    `  TOTAL                    \u2248 ${r.totals.minCredits.toFixed(3)} \u2013 ${r.totals.maxCredits.toFixed(3)} credit`
+  );
+  lines.push(`  TOTAL (duration estimate) \u2248 ${r.totals.minSeconds}s \u2013 ${r.totals.maxSeconds}s`);
+  lines.push("");
+  lines.push("  Note: ranges are heuristic. Actual cost depends on row counts, data layout,");
+  lines.push("  and what other workloads share the warehouse. Treat the upper bound as a");
+  lines.push("  pessimistic ceiling, not a likely outcome.");
+  return lines.join("\n");
+}
+function renderMarkdown(r) {
+  const lines = [];
+  lines.push(`# Cost estimate`);
+  lines.push("");
+  lines.push(`**Warehouse:** ${r.warehouseSize} (${r.creditsPerHour} credit/hour)`);
+  lines.push(
+    `**Statements:** ${r.totalStatements} total, ${r.classifiedStatements} classified, ${r.unknownStatements} unknown`
+  );
+  lines.push("");
+  lines.push(`## Estimate by statement class`);
+  lines.push("");
+  lines.push("| Class | Count | Credit range |");
+  lines.push("|---|---|---|");
+  for (const c of r.perClass) {
+    lines.push(
+      `| \`${c.id}\` (${c.description}) | ${c.count} | ${c.minCredits.toFixed(3)} \u2013 ${c.maxCredits.toFixed(3)} |`
+    );
+  }
+  lines.push("");
+  lines.push(
+    `**Total:** ${r.totals.minCredits.toFixed(3)} \u2013 ${r.totals.maxCredits.toFixed(3)} credit (${r.totals.minSeconds}\u2013${r.totals.maxSeconds}s)`
+  );
+  lines.push("");
+  lines.push("> Ranges are heuristic. Actual cost depends on row counts and warehouse contention.");
+  return lines.join("\n");
+}
+export {
+  costEstimateCommand
+};
+//# sourceMappingURL=cost-estimate-TJDDH6TO.js.map

package/dist/cost-estimate-TJDDH6TO.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/cost-estimate.ts"],"sourcesContent":["import { promises as fs } from 'node:fs';\nimport path from 'node:path';\nimport { Command } from 'commander';\nimport { attachExplainFlag, runExplain } from '../util/ai-explain.js';\n\ninterface HistoryEntry {\n  sqlText?: string;\n  durationMs?: number;\n}\n\n/**\n * `sdt cost-estimate` — static heuristic estimator for the Snowflake\n * credits a migration script will consume when applied.\n *\n * Approach: classify each statement by its observable cost-class\n * (TABLE rebuild, CREATE OR REPLACE VIEW, ADD COLUMN, ALTER TYPE,\n * dynamic-table refresh, etc.) and assign a credit-band estimate per\n * class. Estimates are intentionally **ranges** rather than point\n * values because actual cost depends on row count, warehouse size,\n * and data layout — we don't pretend otherwise.\n *\n * The framing alone is uniquely valuable: no other Snowflake schema\n * tool surfaces \"this migration will roughly cost X credits at S\n * warehouse\" before you apply it.\n *\n * The classifier is regex-based and conservative — when a statement\n * doesn't match a known cost-class it's reported as\n * \"unknown / negligible\" so the user knows the estimate didn't see it.\n */\nexport function costEstimateCommand(): Command {\n  const cmd = new Command('cost-estimate');\n  cmd\n    .description('Heuristic Snowflake-credit estimate for a generated migration script.')\n    .requiredOption(\n      '--script <path>',\n      'Path to a generated migration script (.sql) from `sdt publish --out`.',\n    )\n    .option(\n      '--warehouse-size <size>',\n      'Target warehouse size for the cost ladder: XS | S | M | L | XL | 2XL | 3XL | 4XL.',\n      'S',\n    )\n    .option('--format <fmt>', 'table | json | markdown. Default table.', 'table')\n    .option('-o, --out <path>', 'Write output to file. Defaults to stdout.')\n    .option(\n      '--calibrate-from <path>',\n      'AI Phase 6 calibration: a JSON file of QueryHistoryEntry[] from prior deploys. Each historic statement is classified against the same cost-classes; classes with ≥3 samples adopt empirical min/max duration in place of the heuristic range.',\n    )\n    .action(\n      async (opts: {\n        script: string;\n        warehouseSize?: string;\n        format?: string;\n        out?: string;\n        calibrateFrom?: string;\n        explain?: boolean;\n      }) => {\n        const sql = await fs.readFile(path.resolve(String(opts.script)), 'utf8');\n        const wh = String(opts.warehouseSize ?? 'S').toUpperCase() as WarehouseSize;\n        const wantedSizes: readonly WarehouseSize[] = [\n          'XS',\n          'S',\n          'M',\n          'L',\n          'XL',\n          '2XL',\n          '3XL',\n          '4XL',\n        ];\n        if (!wantedSizes.includes(wh)) {\n          throw new Error(\n            `Unknown --warehouse-size: ${wh}. Use one of ${wantedSizes.join(' | ')}.`,\n          );\n        }\n        let calibration: ClassCalibration | undefined;\n        if (opts.calibrateFrom) {\n          const histRaw = await fs.readFile(path.resolve(String(opts.calibrateFrom)), 'utf8');\n          const parsed = JSON.parse(histRaw);\n          const entries: HistoryEntry[] = Array.isArray(parsed)\n            ? parsed\n            : Array.isArray(parsed.entries)\n              ? parsed.entries\n              : [];\n          calibration = buildCalibration(entries);\n        }\n        const report = estimateCost(sql, wh, calibration);\n\n        const fmt = String(opts.format ?? 'table').toLowerCase();\n        let payload: string;\n        if (fmt === 'json') {\n          payload = JSON.stringify(report, null, 2);\n        } else if (fmt === 'markdown') {\n          payload = renderMarkdown(report);\n        } else {\n          payload = renderTable(report);\n        }\n        if (opts.out) {\n          const p = path.resolve(String(opts.out));\n          await fs.mkdir(path.dirname(p), { recursive: true });\n          await fs.writeFile(p, payload + (payload.endsWith('\\n') ? '' : '\\n'), 'utf8');\n          console.error(`Wrote ${p}.`);\n        } else {\n          process.stdout.write(payload + (payload.endsWith('\\n') ? '' : '\\n'));\n        }\n        await runExplain(\n          {\n            feature: 'cost-estimate.explain',\n            systemPrompt:\n              'You are a Snowflake cost engineer. Walk the team through this cost estimate: what is the dominant cost driver, what does the range mean in practice, and what knobs (warehouse size, sequencing, off-peak timing) would meaningfully reduce it.',\n          },\n          opts,\n          () =>\n            `Cost estimate (JSON) follows:\\n\\n${JSON.stringify(report, null, 2)}\\n\\nNarrate this for a teammate.`,\n        );\n      },\n    );\n  attachExplainFlag(cmd);\n  return cmd;\n}\n\ntype WarehouseSize = 'XS' | 'S' | 'M' | 'L' | 'XL' | '2XL' | '3XL' | '4XL';\n\n/**\n * Snowflake's published credit-per-hour ladder, as of 2026-Q1.\n * XS = 1, S = 2, M = 4, L = 8, XL = 16, 2XL = 32, 3XL = 64, 4XL = 128.\n */\nconst CREDITS_PER_HOUR: Record<WarehouseSize, number> = {\n  XS: 1,\n  S: 2,\n  M: 4,\n  L: 8,\n  XL: 16,\n  '2XL': 32,\n  '3XL': 64,\n  '4XL': 128,\n};\n\ninterface CostClass {\n  id: string;\n  description: string;\n  /** Conservative range estimate in **seconds of warehouse time**. */\n  minSeconds: number;\n  maxSeconds: number;\n  /** Regex that matches the statement category. */\n  test: (sql: string) => boolean;\n}\n\nconst COST_CLASSES: CostClass[] = [\n  {\n    id: 'table-rebuild',\n    description: 'CREATE OR REPLACE TABLE or CTAS — rewrites the entire table',\n    minSeconds: 30,\n    maxSeconds: 1800,\n    test: (s) =>\n      /CREATE\\s+(?:OR\\s+REPLACE\\s+)?TABLE\\s+.+\\s+AS\\s+SELECT/i.test(s) ||\n      /CREATE\\s+OR\\s+REPLACE\\s+TABLE\\b/i.test(s),\n  },\n  {\n    id: 'add-column',\n    description: 'ALTER TABLE ADD COLUMN — metadata-only, no scan',\n    minSeconds: 1,\n    maxSeconds: 5,\n    test: (s) => /ALTER\\s+TABLE\\b.*\\bADD\\s+COLUMN\\b/i.test(s),\n  },\n  {\n    id: 'drop-column',\n    description: 'ALTER TABLE DROP COLUMN — metadata-only',\n    minSeconds: 1,\n    maxSeconds: 5,\n    test: (s) => /ALTER\\s+TABLE\\b.*\\bDROP\\s+COLUMN\\b/i.test(s),\n  },\n  {\n    id: 'alter-type-narrowing',\n    description: 'ALTER COLUMN TYPE (narrowing) — full data scan + rewrite',\n    minSeconds: 30,\n    maxSeconds: 600,\n    test: (s) => /ALTER\\s+TABLE\\b.*\\bALTER\\s+COLUMN\\b.*\\bSET\\s+DATA\\s+TYPE\\b/i.test(s),\n  },\n  {\n    id: 'create-view',\n    description: 'CREATE OR REPLACE VIEW — metadata-only',\n    minSeconds: 1,\n    maxSeconds: 3,\n    test: (s) => /CREATE\\s+(?:OR\\s+REPLACE\\s+)?VIEW\\b/i.test(s),\n  },\n  {\n    id: 'create-mv',\n    description: 'CREATE MATERIALIZED VIEW — initial population can be costly',\n    minSeconds: 60,\n    maxSeconds: 3600,\n    test: (s) => /CREATE\\s+(?:OR\\s+REPLACE\\s+)?MATERIALIZED\\s+VIEW\\b/i.test(s),\n  },\n  {\n    id: 'create-dynamic-table',\n    description: 'CREATE DYNAMIC TABLE — initial materialisation cost',\n    minSeconds: 60,\n    maxSeconds: 1800,\n    test: (s) => /CREATE\\s+(?:OR\\s+REPLACE\\s+)?DYNAMIC\\s+TABLE\\b/i.test(s),\n  },\n  {\n    id: 'create-stream',\n    description: 'CREATE STREAM — metadata-only',\n    minSeconds: 1,\n    maxSeconds: 3,\n    test: (s) => /CREATE\\s+(?:OR\\s+REPLACE\\s+)?STREAM\\b/i.test(s),\n  },\n  {\n    id: 'create-task',\n    description: 'CREATE TASK — metadata-only',\n    minSeconds: 1,\n    maxSeconds: 3,\n    test: (s) => /CREATE\\s+(?:OR\\s+REPLACE\\s+)?TASK\\b/i.test(s),\n  },\n  {\n    id: 'create-warehouse',\n    description: 'CREATE WAREHOUSE — metadata; cost depends on usage',\n    minSeconds: 1,\n    maxSeconds: 5,\n    test: (s) => /CREATE\\s+(?:OR\\s+REPLACE\\s+)?WAREHOUSE\\b/i.test(s),\n  },\n  {\n    id: 'pre-deploy-clone',\n    description: 'CREATE DATABASE ... CLONE — Snowflake zero-copy clone (~instant)',\n    minSeconds: 1,\n    maxSeconds: 10,\n    test: (s) => /CREATE\\s+(?:OR\\s+REPLACE\\s+)?DATABASE\\s+\\S+\\s+CLONE\\b/i.test(s),\n  },\n  {\n    id: 'drop',\n    description: 'DROP statement — metadata-only',\n    minSeconds: 1,\n    maxSeconds: 3,\n    test: (s) => /^\\s*DROP\\s+/i.test(s),\n  },\n  {\n    id: 'grant',\n    description: 'GRANT / REVOKE — metadata-only',\n    minSeconds: 1,\n    maxSeconds: 2,\n    test: (s) => /^\\s*(?:GRANT|REVOKE)\\s+/i.test(s),\n  },\n  {\n    id: 'comment',\n    description: 'COMMENT-only statement (-- … no DDL) — free',\n    minSeconds: 0,\n    maxSeconds: 0,\n    test: (s) =>\n      s\n        .replace(/--[^\\n]*/g, '')\n        .replace(/\\/\\*[\\s\\S]*?\\*\\//g, '')\n        .trim().length === 0,\n  },\n];\n\ninterface CostReport {\n  warehouseSize: WarehouseSize;\n  creditsPerHour: number;\n  totalStatements: number;\n  classifiedStatements: number;\n  unknownStatements: number;\n  perClass: Array<{\n    id: string;\n    description: string;\n    count: number;\n    minSeconds: number;\n    maxSeconds: number;\n    minCredits: number;\n    maxCredits: number;\n    /** When set, the per-statement range came from this many empirical samples. */\n    calibratedFromSamples?: number;\n  }>;\n  totals: {\n    minSeconds: number;\n    maxSeconds: number;\n    minCredits: number;\n    maxCredits: number;\n  };\n}\n\n/**\n * AI Phase 6 calibration — per-class empirical duration ranges harvested\n * from prior `QueryHistoryEntry[]` (typed in `@<tool>/core/queryHistory`).\n * When a class has at least 3 historic samples, its heuristic min/max is\n * replaced with the observed min/max. Classes that fall back to the\n * heuristic are flagged in the report so the user can see what was\n * calibrated.\n */\ninterface ClassCalibration {\n  /** Per-class empirical range; absent classes use the heuristic range. */\n  perClass: Record<string, { sampleSize: number; minSeconds: number; maxSeconds: number }>;\n}\n\nfunction buildCalibration(entries: HistoryEntry[]): ClassCalibration {\n  const samples = new Map<string, number[]>();\n  for (const e of entries) {\n    const sql = typeof e.sqlText === 'string' ? e.sqlText : '';\n    const dur = typeof e.durationMs === 'number' ? e.durationMs : NaN;\n    if (!sql || !isFinite(dur) || dur <= 0) continue;\n    const matched = COST_CLASSES.find((c) => c.test(sql));\n    if (!matched) continue;\n    const arr = samples.get(matched.id) ?? [];\n    arr.push(dur / 1000);\n    samples.set(matched.id, arr);\n  }\n  const perClass: ClassCalibration['perClass'] = {};\n  for (const [id, durs] of samples) {\n    if (durs.length < 3) continue;\n    durs.sort((a, b) => a - b);\n    perClass[id] = {\n      sampleSize: durs.length,\n      minSeconds: Math.max(1, Math.round(durs[0]!)),\n      maxSeconds: Math.max(1, Math.round(durs[durs.length - 1]!)),\n    };\n  }\n  return { perClass };\n}\n\nfunction estimateCost(\n  sql: string,\n  warehouseSize: WarehouseSize,\n  calibration?: ClassCalibration,\n): CostReport {\n  const statements = splitStatements(sql);\n  const classCounts = new Map<string, number>();\n  let classifiedStatements = 0;\n  let unknownStatements = 0;\n  for (const stmt of statements) {\n    const matched = COST_CLASSES.find((c) => c.test(stmt));\n    if (matched) {\n      classCounts.set(matched.id, (classCounts.get(matched.id) ?? 0) + 1);\n      classifiedStatements++;\n    } else if (stmt.trim().length > 0) {\n      unknownStatements++;\n    }\n  }\n  const creditsPerHour = CREDITS_PER_HOUR[warehouseSize];\n  const perClass = COST_CLASSES.filter((c) => (classCounts.get(c.id) ?? 0) > 0).map((c) => {\n    const count = classCounts.get(c.id) ?? 0;\n    const cal = calibration?.perClass[c.id];\n    const minSecondsPerStmt = cal ? cal.minSeconds : c.minSeconds;\n    const maxSecondsPerStmt = cal ? cal.maxSeconds : c.maxSeconds;\n    const minSeconds = minSecondsPerStmt * count;\n    const maxSeconds = maxSecondsPerStmt * count;\n    return {\n      id: c.id,\n      description: c.description,\n      count,\n      minSeconds,\n      maxSeconds,\n      minCredits: (minSeconds / 3600) * creditsPerHour,\n      maxCredits: (maxSeconds / 3600) * creditsPerHour,\n      ...(cal ? { calibratedFromSamples: cal.sampleSize } : {}),\n    };\n  });\n  const totals = perClass.reduce(\n    (acc, c) => ({\n      minSeconds: acc.minSeconds + c.minSeconds,\n      maxSeconds: acc.maxSeconds + c.maxSeconds,\n      minCredits: acc.minCredits + c.minCredits,\n      maxCredits: acc.maxCredits + c.maxCredits,\n    }),\n    { minSeconds: 0, maxSeconds: 0, minCredits: 0, maxCredits: 0 },\n  );\n  return {\n    warehouseSize,\n    creditsPerHour,\n    totalStatements: statements.length,\n    classifiedStatements,\n    unknownStatements,\n    perClass,\n    totals,\n  };\n}\n\nfunction splitStatements(sql: string): string[] {\n  return sql\n    .replace(/\\/\\*[\\s\\S]*?\\*\\//g, '')\n    .split(/;\\s*$/m)\n    .map((s) => s.trim())\n    .filter(Boolean);\n}\n\nfunction renderTable(r: CostReport): string {\n  const lines: string[] = [];\n  lines.push(`Cost estimate — warehouse=${r.warehouseSize} (${r.creditsPerHour} credit/hour)`);\n  lines.push('');\n  lines.push(\n    `  Statements: ${r.totalStatements} (${r.classifiedStatements} classified, ${r.unknownStatements} unknown).`,\n  );\n  lines.push('');\n  const idW = Math.max(20, ...r.perClass.map((c) => c.id.length));\n  for (const c of r.perClass) {\n    lines.push(\n      `  ${c.id.padEnd(idW)}  ×${String(c.count).padStart(4)}  ≈ ${c.minCredits.toFixed(3)} – ${c.maxCredits.toFixed(3)} credit`,\n    );\n  }\n  lines.push('');\n  lines.push(\n    `  TOTAL                    ≈ ${r.totals.minCredits.toFixed(3)} – ${r.totals.maxCredits.toFixed(3)} credit`,\n  );\n  lines.push(`  TOTAL (duration estimate) ≈ ${r.totals.minSeconds}s – ${r.totals.maxSeconds}s`);\n  lines.push('');\n  lines.push('  Note: ranges are heuristic. Actual cost depends on row counts, data layout,');\n  lines.push('  and what other workloads share the warehouse. Treat the upper bound as a');\n  lines.push('  pessimistic ceiling, not a likely outcome.');\n  return lines.join('\\n');\n}\n\nfunction renderMarkdown(r: CostReport): string {\n  const lines: string[] = [];\n  lines.push(`# Cost estimate`);\n  lines.push('');\n  lines.push(`**Warehouse:** ${r.warehouseSize} (${r.creditsPerHour} credit/hour)`);\n  lines.push(\n    `**Statements:** ${r.totalStatements} total, ${r.classifiedStatements} classified, ${r.unknownStatements} unknown`,\n  );\n  lines.push('');\n  lines.push(`## Estimate by statement class`);\n  lines.push('');\n  lines.push('| Class | Count | Credit range |');\n  lines.push('|---|---|---|');\n  for (const c of r.perClass) {\n    lines.push(\n      `| \\`${c.id}\\` (${c.description}) | ${c.count} | ${c.minCredits.toFixed(3)} – ${c.maxCredits.toFixed(3)} |`,\n    );\n  }\n  lines.push('');\n  lines.push(\n    `**Total:** ${r.totals.minCredits.toFixed(3)} – ${r.totals.maxCredits.toFixed(3)} credit (${r.totals.minSeconds}–${r.totals.maxSeconds}s)`,\n  );\n  lines.push('');\n  lines.push('> Ranges are heuristic. Actual cost depends on row counts and warehouse contention.');\n  return lines.join('\\n');\n}\n"],"mappings":"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","names":[]}

package/dist/data-compare-UK2UXAS3.js

@@ -0,0 +1,134 @@
+import {
+  logger
+} from "./chunk-VM2H4LAO.js";
+import "./chunk-DGUM43GV.js";
+
+// src/commands/data-compare.ts
+import { promises as fs } from "fs";
+import path from "path";
+import { Command } from "commander";
+import { dataCompare } from "@sdt-tools/core";
+import { getProfile, SnowflakeConnection } from "@sdt-tools/core/connection";
+function dataCompareCommand() {
+  const cmd = new Command("data-compare");
+  cmd.description(
+    "Row-level data compare: diff two tables by primary key and emit an INSERT/UPDATE/DELETE script that converts target into source. Source/target rows read from JSON files in v1."
+  ).requiredOption(
+    "--table <fqn>",
+    "Fully-qualified table name to embed in the emitted script (DATABASE.SCHEMA.TABLE)."
+  ).requiredOption("--key <cols>", "Comma-separated primary-key columns.").option(
+    "--source <path>",
+    "JSON file containing the source-side rows (TableRow[]). Mutually exclusive with --source-live."
+  ).option(
+    "--target <path>",
+    "JSON file containing the target-side rows (TableRow[]). Mutually exclusive with --target-live."
+  ).option(
+    "--source-live <profile>",
+    "Connection profile to read source rows from live via SELECT * FROM --table. Mutually exclusive with --source."
+  ).option(
+    "--target-live <profile>",
+    "Connection profile to read target rows from live via SELECT * FROM --table. Mutually exclusive with --target."
+  ).option(
+    "--row-limit <n>",
+    "Cap rows fetched per side in live mode. Default 100000. Use 0 for unbounded (DANGER on prod tables).",
+    "100000"
+  ).option(
+    "--columns <cols>",
+    "Comma-separated column list to consider. Defaults to all keys seen in the rows."
+  ).option(
+    "--max-changes <n>",
+    "Cap the changed-row count (added/removed are not capped). Default 10000.",
+    "10000"
+  ).option(
+    "--case-sensitive",
+    "Compare column names case-sensitively (default: false \u2014 Snowflake idiom).",
+    false
+  ).option("--no-transaction", "Omit BEGIN/COMMIT wrappers from the emitted script.").option("--no-header", "Omit the REVIEW header from the emitted script.").option("--format <fmt>", "Output format: sql | json. Default sql.", "sql").option("-o, --output <path>", "Write output to a file instead of stdout.").action(async (opts) => {
+    await runDataCompare(opts, "snowflake");
+  });
+  return cmd;
+}
+async function runDataCompare(opts, dialect) {
+  const fqn = String(opts.table);
+  const keyColumns = String(opts.key).split(",").map((s) => s.trim()).filter(Boolean);
+  if (keyColumns.length === 0) {
+    throw new Error("--key must include at least one column.");
+  }
+  const columns = opts.columns ? String(opts.columns).split(",").map((s) => s.trim()).filter(Boolean) : void 0;
+  const sourceJson = opts.source;
+  const targetJson = opts.target;
+  const sourceLive = opts.sourceLive;
+  const targetLive = opts.targetLive;
+  if (Boolean(sourceJson) === Boolean(sourceLive)) {
+    throw new Error("Specify exactly one of --source or --source-live.");
+  }
+  if (Boolean(targetJson) === Boolean(targetLive)) {
+    throw new Error("Specify exactly one of --target or --target-live.");
+  }
+  const rowLimit = Number(opts.rowLimit ?? "100000");
+  const [sourceRows, targetRows] = await Promise.all([
+    sourceLive ? fetchLiveRows(sourceLive, fqn, columns, rowLimit, "source") : readRowsFile(String(sourceJson)),
+    targetLive ? fetchLiveRows(targetLive, fqn, columns, rowLimit, "target") : readRowsFile(String(targetJson))
+  ]);
+  const result = dataCompare.diffRows(
+    {
+      fqn,
+      keyColumns,
+      ...columns ? { columns } : {},
+      sourceRows,
+      targetRows
+    },
+    {
+      maxChanges: Number(opts.maxChanges ?? "10000") || 1e4,
+      caseSensitiveColumns: opts.caseSensitive === true
+    }
+  );
+  const format = String(opts.format).toLowerCase();
+  const out = format === "json" ? JSON.stringify(result, null, 2) : dataCompare.renderDataCompareScript(result, dialect, {
+    transactional: opts.transaction !== false,
+    includeHeader: opts.header !== false
+  });
+  if (opts.output) {
+    const outPath = path.resolve(String(opts.output));
+    await fs.writeFile(outPath, out, "utf8");
+    logger.info(
+      `data-compare: wrote ${outPath} (added=${result.diff.added.length} removed=${result.diff.removed.length} changed=${result.diff.changed.length} unchanged=${result.diff.unchanged}${result.truncated ? " truncated" : ""})`
+    );
+  } else {
+    process.stdout.write(out);
+    if (format !== "json") process.stdout.write("\n");
+  }
+}
+async function readRowsFile(p) {
+  const raw = await fs.readFile(path.resolve(p), "utf8");
+  const parsed = JSON.parse(raw);
+  if (!Array.isArray(parsed)) {
+    throw new Error(`${p}: expected a JSON array of row objects.`);
+  }
+  return parsed;
+}
+async function fetchLiveRows(profileName, fqn, columns, rowLimit, side) {
+  const projection = columns && columns.length > 0 ? columns.join(", ") : "*";
+  const limit = rowLimit > 0 ? ` LIMIT ${Math.floor(rowLimit)}` : "";
+  const sql = `SELECT ${projection} FROM ${fqn}${limit}`;
+  const profile = await getProfile(profileName);
+  const conn = new SnowflakeConnection(profile);
+  logger.step(
+    `data-compare (${side}): connecting to ${profile.account} as ${profile.auth.username}\u2026`
+  );
+  await conn.connect();
+  try {
+    const rows = await conn.executeRows(sql);
+    logger.info(
+      `data-compare (${side}): fetched ${rows.length} row(s) from ${fqn}${rowLimit > 0 && rows.length === rowLimit ? " (LIMIT reached \u2014 increase --row-limit if more rows are needed)" : ""}.`
+    );
+    return rows;
+  } finally {
+    await conn.disconnect().catch(() => void 0);
+  }
+}
+export {
+  dataCompareCommand,
+  runDataCompare
+};
+//# sourceMappingURL=data-compare-UK2UXAS3.js.map

package/dist/data-compare-UK2UXAS3.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/data-compare.ts"],"sourcesContent":["/**\n * `sdt data-compare` — Tier-1 SSDT-gap row-level data compare.\n *\n * Reads source + target rows from either:\n *  - JSON files (`--source` / `--target`), or\n *  - live warehouses (`--source-live <profile>` / `--target-live <profile>`)\n *    via `SnowflakeConnection.executeRows`.\n *\n * Live mode runs `SELECT <columns> FROM <fqn>` against each side and\n * pipes rows through the dialect-aware `dataCompare.diffRows` substrate.\n *\n * Usage (JSON):\n *   sdt data-compare --table DB.S.T --key ID \\\n *     --source rows-source.json --target rows-target.json\n *\n * Usage (live):\n *   sdt data-compare --table DB.S.T --key ID \\\n *     --source-live dev --target-live prod \\\n *     [--columns ID,EMAIL,STATUS] [--row-limit 50000]\n *\n * Mirrors `ddt data-compare`.\n */\nimport { promises as fs } from 'fs';\nimport path from 'path';\nimport { Command } from 'commander';\nimport { dataCompare } from '@sdt-tools/core';\nimport { getProfile, SnowflakeConnection } from '@sdt-tools/core/connection';\nimport { logger } from '../util/logger.js';\n\nexport function dataCompareCommand(): Command {\n  const cmd = new Command('data-compare');\n  cmd\n    .description(\n      'Row-level data compare: diff two tables by primary key and emit an INSERT/UPDATE/DELETE script ' +\n        'that converts target into source. Source/target rows read from JSON files in v1.',\n    )\n    .requiredOption(\n      '--table <fqn>',\n      'Fully-qualified table name to embed in the emitted script (DATABASE.SCHEMA.TABLE).',\n    )\n    .requiredOption('--key <cols>', 'Comma-separated primary-key columns.')\n    .option(\n      '--source <path>',\n      'JSON file containing the source-side rows (TableRow[]). Mutually exclusive with --source-live.',\n    )\n    .option(\n      '--target <path>',\n      'JSON file containing the target-side rows (TableRow[]). Mutually exclusive with --target-live.',\n    )\n    .option(\n      '--source-live <profile>',\n      'Connection profile to read source rows from live via SELECT * FROM --table. Mutually exclusive with --source.',\n    )\n    .option(\n      '--target-live <profile>',\n      'Connection profile to read target rows from live via SELECT * FROM --table. Mutually exclusive with --target.',\n    )\n    .option(\n      '--row-limit <n>',\n      'Cap rows fetched per side in live mode. Default 100000. Use 0 for unbounded (DANGER on prod tables).',\n      '100000',\n    )\n    .option(\n      '--columns <cols>',\n      'Comma-separated column list to consider. Defaults to all keys seen in the rows.',\n    )\n    .option(\n      '--max-changes <n>',\n      'Cap the changed-row count (added/removed are not capped). Default 10000.',\n      '10000',\n    )\n    .option(\n      '--case-sensitive',\n      'Compare column names case-sensitively (default: false — Snowflake idiom).',\n      false,\n    )\n    .option('--no-transaction', 'Omit BEGIN/COMMIT wrappers from the emitted script.')\n    .option('--no-header', 'Omit the REVIEW header from the emitted script.')\n    .option('--format <fmt>', 'Output format: sql | json. Default sql.', 'sql')\n    .option('-o, --output <path>', 'Write output to a file instead of stdout.')\n    .action(async (opts) => {\n      await runDataCompare(opts, 'snowflake');\n    });\n  return cmd;\n}\n\nexport async function runDataCompare(\n  opts: Record<string, unknown>,\n  dialect: 'snowflake' | 'databricks',\n): Promise<void> {\n  const fqn = String(opts.table);\n  const keyColumns = String(opts.key)\n    .split(',')\n    .map((s) => s.trim())\n    .filter(Boolean);\n  if (keyColumns.length === 0) {\n    throw new Error('--key must include at least one column.');\n  }\n  const columns = opts.columns\n    ? String(opts.columns)\n        .split(',')\n        .map((s) => s.trim())\n        .filter(Boolean)\n    : undefined;\n\n  const sourceJson = opts.source as string | undefined;\n  const targetJson = opts.target as string | undefined;\n  const sourceLive = opts.sourceLive as string | undefined;\n  const targetLive = opts.targetLive as string | undefined;\n  if (Boolean(sourceJson) === Boolean(sourceLive)) {\n    throw new Error('Specify exactly one of --source or --source-live.');\n  }\n  if (Boolean(targetJson) === Boolean(targetLive)) {\n    throw new Error('Specify exactly one of --target or --target-live.');\n  }\n  const rowLimit = Number(opts.rowLimit ?? '100000');\n\n  const [sourceRows, targetRows] = await Promise.all([\n    sourceLive\n      ? fetchLiveRows(sourceLive, fqn, columns, rowLimit, 'source')\n      : readRowsFile(String(sourceJson)),\n    targetLive\n      ? fetchLiveRows(targetLive, fqn, columns, rowLimit, 'target')\n      : readRowsFile(String(targetJson)),\n  ]);\n\n  const result = dataCompare.diffRows(\n    {\n      fqn,\n      keyColumns,\n      ...(columns ? { columns } : {}),\n      sourceRows,\n      targetRows,\n    },\n    {\n      maxChanges: Number(opts.maxChanges ?? '10000') || 10_000,\n      caseSensitiveColumns: opts.caseSensitive === true,\n    },\n  );\n\n  const format = String(opts.format).toLowerCase();\n  const out =\n    format === 'json'\n      ? JSON.stringify(result, null, 2)\n      : dataCompare.renderDataCompareScript(result, dialect, {\n          transactional: opts.transaction !== false,\n          includeHeader: opts.header !== false,\n        });\n\n  if (opts.output) {\n    const outPath = path.resolve(String(opts.output));\n    await fs.writeFile(outPath, out, 'utf8');\n    logger.info(\n      `data-compare: wrote ${outPath} (added=${result.diff.added.length} ` +\n        `removed=${result.diff.removed.length} changed=${result.diff.changed.length} ` +\n        `unchanged=${result.diff.unchanged}${result.truncated ? ' truncated' : ''})`,\n    );\n  } else {\n    process.stdout.write(out);\n    if (format !== 'json') process.stdout.write('\\n');\n  }\n}\n\nasync function readRowsFile(p: string): Promise<dataCompare.TableRow[]> {\n  const raw = await fs.readFile(path.resolve(p), 'utf8');\n  const parsed = JSON.parse(raw) as unknown;\n  if (!Array.isArray(parsed)) {\n    throw new Error(`${p}: expected a JSON array of row objects.`);\n  }\n  return parsed as dataCompare.TableRow[];\n}\n\nasync function fetchLiveRows(\n  profileName: string,\n  fqn: string,\n  columns: readonly string[] | undefined,\n  rowLimit: number,\n  side: 'source' | 'target',\n): Promise<dataCompare.TableRow[]> {\n  const projection = columns && columns.length > 0 ? columns.join(', ') : '*';\n  const limit = rowLimit > 0 ? ` LIMIT ${Math.floor(rowLimit)}` : '';\n  const sql = `SELECT ${projection} FROM ${fqn}${limit}`;\n  const profile = await getProfile(profileName);\n  const conn = new SnowflakeConnection(profile);\n  logger.step(\n    `data-compare (${side}): connecting to ${profile.account} as ${profile.auth.username}…`,\n  );\n  await conn.connect();\n  try {\n    const rows = await conn.executeRows(sql);\n    logger.info(\n      `data-compare (${side}): fetched ${rows.length} row(s) from ${fqn}${rowLimit > 0 && rows.length === rowLimit ? ' (LIMIT reached — increase --row-limit if more rows are needed)' : ''}.`,\n    );\n    return rows as dataCompare.TableRow[];\n  } finally {\n    await conn.disconnect().catch(() => undefined);\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/data-fit-Q45ENBRL.js

@@ -0,0 +1,125 @@
+import "./chunk-DGUM43GV.js";
+
+// src/commands/data-fit.ts
+import { promises as fs } from "fs";
+import path from "path";
+import { Command } from "commander";
+import { CompareEngine, PacSource } from "@sdt-tools/core/compare";
+import { classifyTypeChange, dataFitProbeSql } from "@sdt-tools/core/types";
+function getColumns(obj) {
+  if (!("columns" in obj)) return void 0;
+  const cols = obj.columns;
+  if (!Array.isArray(cols)) return void 0;
+  return cols;
+}
+function dataTypeToString(dt) {
+  if (typeof dt === "string") return dt;
+  if (dt && typeof dt === "object") {
+    const d = dt;
+    if (d.raw) return d.raw;
+    if (!d.base) return JSON.stringify(dt);
+    if (d.precision !== void 0 && d.scale !== void 0) {
+      return `${d.base}(${d.precision},${d.scale})`;
+    }
+    if (d.length !== void 0) return `${d.base}(${d.length})`;
+    return d.base;
+  }
+  return String(dt ?? "");
+}
+function quotedFqn(obj) {
+  const fqn = obj.fqn;
+  if (!fqn) return "<unknown>";
+  return [fqn.database, fqn.schema, fqn.name].filter(Boolean).map((p) => `"${p}"`).join(".");
+}
+function quotedCol(name) {
+  return `"${name}"`;
+}
+function dataFitCommand() {
+  const cmd = new Command("data-fit");
+  cmd.description(
+    "Emit pre-flight SELECT count_if() probes for every narrowing type change in a pac\u2194pac compare. Run them against the live target before --apply."
+  ).requiredOption("--source <path>", ".sdtpac with the desired state.").requiredOption("--target <path>", ".sdtpac with the current state.").option("-o, --out <path>", "Output SQL file. Default: stdout.").option("--format <fmt>", "Output format: sql | json. Default: sql.", "sql").action(async (opts) => {
+    const source = new PacSource(path.resolve(String(opts.source)));
+    const target = new PacSource(path.resolve(String(opts.target)));
+    const engine = new CompareEngine();
+    const result = await engine.compare(source, target);
+    const probes = [];
+    for (const obj of result.objects) {
+      if (obj.kind !== "modified" || !obj.source || !obj.target) continue;
+      const srcCols = getColumns(obj.source);
+      const tgtCols = getColumns(obj.target);
+      if (!srcCols || !tgtCols) continue;
+      const byName = /* @__PURE__ */ new Map();
+      for (const c of srcCols) byName.set(c.name.toUpperCase(), { source: c, target: c });
+      for (const c of tgtCols) {
+        const slot = byName.get(c.name.toUpperCase());
+        if (slot) slot.target = c;
+      }
+      for (const [, pair] of byName) {
+        if (pair.source === pair.target) continue;
+        const fromStr = dataTypeToString(pair.target.dataType);
+        const toStr = dataTypeToString(pair.source.dataType);
+        if (fromStr === toStr) continue;
+        const check = classifyTypeChange(fromStr, toStr);
+        if (check.verdict !== "data-fit-required") continue;
+        const fqn = quotedFqn(obj.source);
+        const colName = pair.source.name;
+        const probeSql = dataFitProbeSql(check, fqn, quotedCol(colName));
+        if (!probeSql) continue;
+        probes.push({
+          fqn,
+          column: colName,
+          from: fromStr,
+          to: toStr,
+          reason: check.reason,
+          sql: probeSql
+        });
+      }
+    }
+    if (opts.format === "json") {
+      const out = JSON.stringify({ probeCount: probes.length, probes }, null, 2);
+      await emit(out, opts.out);
+    } else {
+      const lines = [];
+      lines.push(`-- Generated by \`sdt data-fit\` at ${(/* @__PURE__ */ new Date()).toISOString()}.`);
+      lines.push(`-- ${probes.length} narrowing type change(s) need a pre-flight check.`);
+      lines.push(`-- Run each query against the target; WOULD_FAIL must be 0 before --apply.`);
+      lines.push("");
+      for (const p of probes) {
+        lines.push(`-- PROBE: ${p.fqn}.${quotedCol(p.column)}  (${p.from} \u2192 ${p.to})`);
+        lines.push(`-- Reason: ${p.reason}`);
+        lines.push(`${p.sql};`);
+        lines.push("");
+      }
+      if (probes.length === 0) {
+        lines.push(
+          "-- No narrowing type changes detected. Compare result has only safe or destructive changes;"
+        );
+        lines.push("-- data-fit probes do not apply.");
+      }
+      await emit(lines.join("\n"), opts.out);
+    }
+    if (probes.length === 0) {
+      console.error("No narrowing type changes detected \u2014 nothing to probe.");
+    } else {
+      console.error(
+        `Generated ${probes.length} data-fit probe(s). Run each against the target and confirm WOULD_FAIL = 0 before \`sdt publish --apply\`.`
+      );
+    }
+  });
+  return cmd;
+}
+async function emit(text, out) {
+  if (out) {
+    const p = path.resolve(String(out));
+    await fs.mkdir(path.dirname(p), { recursive: true });
+    await fs.writeFile(p, text + (text.endsWith("\n") ? "" : "\n"), "utf8");
+    console.error(`Wrote ${p}.`);
+  } else {
+    process.stdout.write(text + (text.endsWith("\n") ? "" : "\n"));
+  }
+}
+export {
+  dataFitCommand
+};
+//# sourceMappingURL=data-fit-Q45ENBRL.js.map