@syndicalt/snow-cli 1.0.0

package/dist/index.js

@@ -0,0 +1,3025 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/lib/config.ts
+var config_exports = {};
+__export(config_exports, {
+  addInstance: () => addInstance,
+  getAIConfig: () => getAIConfig,
+  getActiveInstance: () => getActiveInstance,
+  getActiveProvider: () => getActiveProvider,
+  listInstances: () => listInstances,
+  loadConfig: () => loadConfig,
+  removeInstance: () => removeInstance,
+  removeProviderConfig: () => removeProviderConfig,
+  requireActiveInstance: () => requireActiveInstance,
+  saveConfig: () => saveConfig,
+  setActiveInstance: () => setActiveInstance,
+  setActiveProvider: () => setActiveProvider,
+  setProviderConfig: () => setProviderConfig
+});
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+function ensureConfigDir() {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true, mode: 448 });
+  }
+}
+function loadConfig() {
+  ensureConfigDir();
+  if (!existsSync(CONFIG_FILE)) {
+    return { instances: {} };
+  }
+  try {
+    const raw = readFileSync(CONFIG_FILE, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return { instances: {} };
+  }
+}
+function saveConfig(config) {
+  ensureConfigDir();
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), { mode: 384 });
+}
+function getActiveInstance() {
+  const config = loadConfig();
+  if (!config.activeInstance) return null;
+  return config.instances[config.activeInstance] ?? null;
+}
+function requireActiveInstance() {
+  const instance = getActiveInstance();
+  if (!instance) {
+    console.error(
+      "No active instance configured. Run `snow instance add` to add one."
+    );
+    process.exit(1);
+  }
+  return instance;
+}
+function addInstance(instance) {
+  const config = loadConfig();
+  config.instances[instance.alias] = instance;
+  if (!config.activeInstance) {
+    config.activeInstance = instance.alias;
+  }
+  saveConfig(config);
+}
+function removeInstance(alias) {
+  const config = loadConfig();
+  if (!config.instances[alias]) return false;
+  delete config.instances[alias];
+  if (config.activeInstance === alias) {
+    const remaining = Object.keys(config.instances);
+    config.activeInstance = remaining[0];
+  }
+  saveConfig(config);
+  return true;
+}
+function setActiveInstance(alias) {
+  const config = loadConfig();
+  if (!config.instances[alias]) return false;
+  config.activeInstance = alias;
+  saveConfig(config);
+  return true;
+}
+function listInstances() {
+  const config = loadConfig();
+  return Object.values(config.instances).map((instance) => ({
+    instance,
+    active: config.activeInstance === instance.alias
+  }));
+}
+function getAIConfig() {
+  const config = loadConfig();
+  return config.ai ?? { providers: {} };
+}
+function setProviderConfig(name, providerConfig) {
+  const config = loadConfig();
+  config.ai ??= { providers: {} };
+  config.ai.providers[name] = providerConfig;
+  if (!config.ai.activeProvider) config.ai.activeProvider = name;
+  saveConfig(config);
+}
+function removeProviderConfig(name) {
+  const config = loadConfig();
+  if (!config.ai?.providers[name]) return false;
+  delete config.ai.providers[name];
+  if (config.ai.activeProvider === name) {
+    const remaining = Object.keys(config.ai.providers);
+    config.ai.activeProvider = remaining[0];
+  }
+  saveConfig(config);
+  return true;
+}
+function setActiveProvider(name) {
+  const config = loadConfig();
+  if (!config.ai?.providers[name]) return false;
+  config.ai.activeProvider = name;
+  saveConfig(config);
+  return true;
+}
+function getActiveProvider() {
+  const ai = getAIConfig();
+  if (!ai.activeProvider) return null;
+  const providerConfig = ai.providers[ai.activeProvider];
+  if (!providerConfig) return null;
+  return { name: ai.activeProvider, config: providerConfig };
+}
+var CONFIG_DIR, CONFIG_FILE;
+var init_config = __esm({
+  "src/lib/config.ts"() {
+    "use strict";
+    init_esm_shims();
+    CONFIG_DIR = join(homedir(), ".snow");
+    CONFIG_FILE = join(CONFIG_DIR, "config.json");
+  }
+});
+
+// src/lib/client.ts
+var client_exports = {};
+__export(client_exports, {
+  ServiceNowClient: () => ServiceNowClient
+});
+import axios from "axios";
+var ServiceNowClient;
+var init_client = __esm({
+  "src/lib/client.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_config();
+    ServiceNowClient = class {
+      http;
+      instance;
+      constructor(instance) {
+        this.instance = instance;
+        this.http = axios.create({
+          baseURL: instance.url.replace(/\/$/, ""),
+          headers: {
+            "Content-Type": "application/json",
+            Accept: "application/json"
+          }
+        });
+        this.http.interceptors.request.use(async (config) => {
+          config.headers = config.headers ?? {};
+          if (this.instance.auth.type === "basic") {
+            const { username, password: password2 } = this.instance.auth;
+            const encoded = Buffer.from(`${username}:${password2}`).toString("base64");
+            config.headers["Authorization"] = `Basic ${encoded}`;
+          } else {
+            const token = await this.getOAuthToken();
+            config.headers["Authorization"] = `Bearer ${token}`;
+          }
+          return config;
+        });
+        this.http.interceptors.response.use(
+          (res) => res,
+          async (err) => {
+            if (axios.isAxiosError(err)) {
+              const status = err.response?.status;
+              const retryable = status === 429 || status === 503 || status === 502;
+              const config = err.config;
+              if (retryable && config) {
+                config._retryCount = (config._retryCount ?? 0) + 1;
+                if (config._retryCount <= 3) {
+                  const retryAfterHeader = err.response?.headers["retry-after"];
+                  const baseDelay = 1e3 * Math.pow(2, config._retryCount - 1);
+                  const delayMs = retryAfterHeader ? Math.max(parseInt(String(retryAfterHeader), 10) * 1e3, baseDelay) : baseDelay;
+                  await new Promise((resolve) => setTimeout(resolve, delayMs));
+                  return this.http.request(config);
+                }
+                const detail2 = err.response?.data?.error?.message ?? err.message;
+                return Promise.reject(
+                  new Error(
+                    `ServiceNow API error (${status}): ${detail2}
+Hint: PDI instances have lower transaction quotas. Wait a moment then retry, or reduce the number of artifacts per build.`
+                  )
+                );
+              }
+              const detail = err.response?.data?.error?.message ?? err.message;
+              return Promise.reject(new Error(`ServiceNow API error (${status}): ${detail}`));
+            }
+            return Promise.reject(err);
+          }
+        );
+      }
+      async getOAuthToken() {
+        const auth = this.instance.auth;
+        const now = Date.now();
+        if (auth.accessToken && auth.tokenExpiry && auth.tokenExpiry > now + 3e4) {
+          return auth.accessToken;
+        }
+        const params = new URLSearchParams({
+          grant_type: "password",
+          client_id: auth.clientId,
+          client_secret: auth.clientSecret
+        });
+        const res = await axios.post(
+          `${this.instance.url.replace(/\/$/, "")}/oauth_token.do`,
+          params.toString(),
+          { headers: { "Content-Type": "application/x-www-form-urlencoded" } }
+        );
+        auth.accessToken = res.data.access_token;
+        auth.tokenExpiry = now + res.data.expires_in * 1e3;
+        const config = loadConfig();
+        config.instances[this.instance.alias].auth = auth;
+        saveConfig(config);
+        return auth.accessToken;
+      }
+      async get(path2, config) {
+        const res = await this.http.get(path2, config);
+        return res.data;
+      }
+      async post(path2, data, config) {
+        const res = await this.http.post(path2, data, config);
+        return res.data;
+      }
+      async put(path2, data, config) {
+        const res = await this.http.put(path2, data, config);
+        return res.data;
+      }
+      async patch(path2, data, config) {
+        const res = await this.http.patch(path2, data, config);
+        return res.data;
+      }
+      async delete(path2, config) {
+        const res = await this.http.delete(path2, config);
+        return res.data;
+      }
+      // Table API helpers
+      async queryTable(table, options = {}) {
+        const params = {};
+        if (options.sysparmQuery) params["sysparm_query"] = options.sysparmQuery;
+        if (options.sysparmFields) params["sysparm_fields"] = options.sysparmFields;
+        if (options.sysparmLimit !== void 0) params["sysparm_limit"] = options.sysparmLimit;
+        if (options.sysparmOffset !== void 0) params["sysparm_offset"] = options.sysparmOffset;
+        if (options.sysparmDisplayValue !== void 0)
+          params["sysparm_display_value"] = String(options.sysparmDisplayValue);
+        if (options.sysparmExcludeReferenceLink !== void 0)
+          params["sysparm_exclude_reference_link"] = options.sysparmExcludeReferenceLink;
+        const res = await this.get(
+          `/api/now/table/${table}`,
+          { params }
+        );
+        return res.result;
+      }
+      async getRecord(table, sysId, options = {}) {
+        const params = {};
+        if (options.sysparmFields) params["sysparm_fields"] = options.sysparmFields;
+        if (options.sysparmDisplayValue !== void 0)
+          params["sysparm_display_value"] = String(options.sysparmDisplayValue);
+        const res = await this.get(
+          `/api/now/table/${table}/${sysId}`,
+          { params }
+        );
+        return res.result;
+      }
+      async createRecord(table, data) {
+        const res = await this.post(`/api/now/table/${table}`, data);
+        return res.result;
+      }
+      async updateRecord(table, sysId, data) {
+        const res = await this.patch(
+          `/api/now/table/${table}/${sysId}`,
+          data
+        );
+        return res.result;
+      }
+      async deleteRecord(table, sysId) {
+        await this.delete(`/api/now/table/${table}/${sysId}`);
+      }
+      async getTableSchema(table) {
+        const res = await this.get(`/api/now/table/${table}?sysparm_limit=0`);
+        return res;
+      }
+      getAxiosInstance() {
+        return this.http;
+      }
+      getInstanceUrl() {
+        return this.instance.url.replace(/\/$/, "");
+      }
+    };
+  }
+});
+
+// src/index.ts
+init_esm_shims();
+import { Command as Command7 } from "commander";
+import chalk7 from "chalk";
+
+// src/commands/instance.ts
+init_esm_shims();
+init_config();
+init_client();
+import { Command } from "commander";
+import chalk from "chalk";
+import { input, password, select, confirm } from "@inquirer/prompts";
+function instanceCommand() {
+  const cmd = new Command("instance").description(
+    "Manage ServiceNow instance connections"
+  );
+  cmd.command("add").description("Add a new ServiceNow instance").option("-a, --alias <alias>", "Alias for the instance").option("-u, --url <url>", "Instance URL (e.g. https://dev12345.service-now.com)").option("--auth <type>", "Auth type: basic or oauth").action(async (opts) => {
+    const alias = opts.alias ?? await input({
+      message: "Alias for this instance:",
+      validate: (v) => v.trim() ? true : "Alias is required"
+    });
+    const config = loadConfig();
+    if (config.instances[alias]) {
+      const overwrite = await confirm({
+        message: `Instance "${alias}" already exists. Overwrite?`,
+        default: false
+      });
+      if (!overwrite) {
+        console.log("Aborted.");
+        return;
+      }
+    }
+    const url = opts.url ?? await input({
+      message: "Instance URL:",
+      validate: (v) => {
+        try {
+          new URL(v);
+          return true;
+        } catch {
+          return "Enter a valid URL (e.g. https://dev12345.service-now.com)";
+        }
+      }
+    });
+    const authType = opts.auth ?? await select({
+      message: "Authentication type:",
+      choices: [
+        { name: "Basic (username/password)", value: "basic" },
+        { name: "OAuth (client credentials)", value: "oauth" }
+      ]
+    });
+    let auth;
+    if (authType === "basic") {
+      const username = await input({
+        message: "Username:",
+        validate: (v) => v.trim() ? true : "Username is required"
+      });
+      const pwd = await password({
+        message: "Password:",
+        mask: "*"
+      });
+      auth = { type: "basic", username, password: pwd };
+    } else {
+      const clientId = await input({
+        message: "OAuth Client ID:",
+        validate: (v) => v.trim() ? true : "Client ID is required"
+      });
+      const clientSecret = await password({
+        message: "OAuth Client Secret:",
+        mask: "*"
+      });
+      auth = { type: "oauth", clientId, clientSecret };
+    }
+    const instance = { alias, url: url.replace(/\/$/, ""), auth };
+    console.log(chalk.dim("Testing connection..."));
+    try {
+      const client = new ServiceNowClient(instance);
+      await client.get("/api/now/table/sys_user?sysparm_limit=1");
+      console.log(chalk.green("Connection successful."));
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.log(chalk.yellow(`Warning: Could not verify connection: ${msg}`));
+      const proceed = await confirm({
+        message: "Save instance anyway?",
+        default: false
+      });
+      if (!proceed) return;
+    }
+    addInstance(instance);
+    console.log(chalk.green(`Instance "${alias}" saved.`));
+    const config2 = loadConfig();
+    if (config2.activeInstance === alias) {
+      console.log(chalk.dim(`"${alias}" is now the active instance.`));
+    }
+  });
+  cmd.command("remove <alias>").description("Remove a configured instance").action(async (alias) => {
+    const ok = await confirm({
+      message: `Remove instance "${alias}"?`,
+      default: false
+    });
+    if (!ok) return;
+    if (removeInstance(alias)) {
+      console.log(chalk.green(`Instance "${alias}" removed.`));
+    } else {
+      console.error(chalk.red(`Instance "${alias}" not found.`));
+      process.exit(1);
+    }
+  });
+  cmd.command("list").alias("ls").description("List configured instances").action(() => {
+    const instances = listInstances();
+    if (instances.length === 0) {
+      console.log("No instances configured. Run `snow instance add` to add one.");
+      return;
+    }
+    for (const { instance, active } of instances) {
+      const marker = active ? chalk.green("*") : " ";
+      const authLabel = instance.auth.type === "basic" ? chalk.dim(`basic (${instance.auth.username})`) : chalk.dim("oauth");
+      console.log(`${marker} ${chalk.bold(instance.alias)}  ${instance.url}  ${authLabel}`);
+    }
+  });
+  cmd.command("use <alias>").description("Switch the active instance").action((alias) => {
+    if (setActiveInstance(alias)) {
+      console.log(chalk.green(`Active instance set to "${alias}".`));
+    } else {
+      console.error(chalk.red(`Instance "${alias}" not found.`));
+      process.exit(1);
+    }
+  });
+  cmd.command("test").description("Test connection to the active instance").action(async () => {
+    const { requireActiveInstance: requireActiveInstance2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+    const instance = requireActiveInstance2();
+    const client = new ServiceNowClient(instance);
+    try {
+      await client.get("/api/now/table/sys_user?sysparm_limit=1");
+      console.log(
+        chalk.green(`Connection to "${instance.alias}" (${instance.url}) is OK.`)
+      );
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(chalk.red(`Connection failed: ${msg}`));
+      process.exit(1);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/table.ts
+init_esm_shims();
+init_config();
+init_client();
+import { Command as Command2 } from "commander";
+import chalk2 from "chalk";
+import ora from "ora";
+function flattenValue(val) {
+  if (val === null || val === void 0) return "";
+  if (typeof val === "object" && !Array.isArray(val)) {
+    const obj = val;
+    if ("display_value" in obj && obj["display_value"] !== "") {
+      return String(obj["display_value"]);
+    }
+    if ("value" in obj) return String(obj["value"]);
+    return JSON.stringify(val);
+  }
+  return String(val);
+}
+function printRecords(records, format) {
+  if (format === "json") {
+    console.log(JSON.stringify(records, null, 2));
+    return;
+  }
+  if (records.length === 0) {
+    console.log(chalk2.dim("No records found."));
+    return;
+  }
+  const rows = records;
+  const allKeys = Object.keys(rows[0]);
+  const keys = allKeys.filter((k) => rows.some((r) => flattenValue(r[k]) !== ""));
+  const termWidth = process.stdout.columns ?? 120;
+  const COL_GAP = 2;
+  const MIN_COL_WIDTH = 10;
+  const fitsHorizontally = keys.length * MIN_COL_WIDTH + COL_GAP * (keys.length - 1) <= termWidth;
+  if (!fitsHorizontally) {
+    const keyWidth = Math.max(...keys.map((k) => k.length));
+    const valWidth = Math.max(20, termWidth - keyWidth - 3);
+    const divider2 = chalk2.dim("\u2500".repeat(Math.min(termWidth, 80)));
+    for (let i = 0; i < rows.length; i++) {
+      console.log(divider2 + chalk2.dim(` Record ${i + 1}`));
+      for (const k of keys) {
+        const val = flattenValue(rows[i][k]);
+        if (val === "") continue;
+        const truncated = val.length > valWidth ? val.slice(0, valWidth - 1) + "\u2026" : val;
+        console.log(`${chalk2.bold(k.padEnd(keyWidth))}  ${truncated}`);
+      }
+      console.log();
+    }
+    console.log(chalk2.dim(`${rows.length} record(s) \u2014 use -f/--fields to select specific fields for tabular output`));
+    return;
+  }
+  const naturalWidths = keys.map((k) => {
+    const maxVal = rows.reduce((max, row) => {
+      return Math.max(max, flattenValue(row[k]).length);
+    }, k.length);
+    return Math.min(maxVal, 60);
+  });
+  const totalNatural = naturalWidths.reduce((s, w) => s + w, 0) + COL_GAP * (keys.length - 1);
+  const colWidths = totalNatural > termWidth ? naturalWidths.map((w) => Math.max(4, Math.floor(w * termWidth / totalNatural))) : naturalWidths;
+  const header = keys.map((k, i) => chalk2.bold(k.padEnd(colWidths[i]))).join("  ");
+  const divider = chalk2.dim(colWidths.map((w) => "\u2500".repeat(w)).join("  "));
+  console.log(header);
+  console.log(divider);
+  for (const row of rows) {
+    const line = keys.map((k, i) => {
+      const val = flattenValue(row[k]);
+      return val.length > colWidths[i] ? val.slice(0, colWidths[i] - 1) + "\u2026" : val.padEnd(colWidths[i]);
+    }).join("  ");
+    console.log(line);
+  }
+  console.log(chalk2.dim(`
+${rows.length} record(s)`));
+}
+function tableCommand() {
+  const cmd = new Command2("table").description("Perform Table API operations");
+  cmd.command("get <table>").description("Query records from a table").option("-q, --query <sysparm_query>", "Encoded query string").option("-f, --fields <fields>", "Comma-separated list of fields to return").option("-l, --limit <n>", "Max number of records", "20").option("-o, --offset <n>", "Offset for pagination", "0").option("--display-value", "Return display values instead of raw values").option("--format <fmt>", "Output format: table or json", "table").option("--json", "Shorthand for --format json").action(
+    async (table, opts) => {
+      const instance = requireActiveInstance();
+      const client = new ServiceNowClient(instance);
+      const options = {
+        sysparmQuery: opts.query,
+        sysparmFields: opts.fields,
+        sysparmLimit: parseInt(opts.limit ?? "20", 10),
+        sysparmOffset: parseInt(opts.offset ?? "0", 10),
+        sysparmDisplayValue: opts.displayValue,
+        sysparmExcludeReferenceLink: true
+      };
+      const spinner = ora(`Querying ${table}...`).start();
+      try {
+        const records = await client.queryTable(table, options);
+        spinner.stop();
+        printRecords(records, opts.json ? "json" : opts.format);
+      } catch (err) {
+        spinner.fail();
+        console.error(chalk2.red(err instanceof Error ? err.message : String(err)));
+        process.exit(1);
+      }
+    }
+  );
+  cmd.command("fetch <table> <sys_id>").description("Fetch a single record by sys_id").option("-f, --fields <fields>", "Comma-separated list of fields to return").option("--display-value", "Return display values").option("--format <fmt>", "Output format: table or json", "table").option("--json", "Shorthand for --format json").action(
+    async (table, sysId, opts) => {
+      const instance = requireActiveInstance();
+      const client = new ServiceNowClient(instance);
+      const spinner = ora(`Fetching ${table}/${sysId}...`).start();
+      try {
+        const record = await client.getRecord(table, sysId, {
+          sysparmFields: opts.fields,
+          sysparmDisplayValue: opts.displayValue
+        });
+        spinner.stop();
+        printRecords([record], opts.json ? "json" : opts.format);
+      } catch (err) {
+        spinner.fail();
+        console.error(chalk2.red(err instanceof Error ? err.message : String(err)));
+        process.exit(1);
+      }
+    }
+  );
+  cmd.command("create <table>").description("Create a new record").requiredOption("-d, --data <json>", "JSON object of field values").option("--format <fmt>", "Output format: table or json", "json").action(
+    async (table, opts) => {
+      let data;
+      try {
+        data = JSON.parse(opts.data);
+      } catch {
+        console.error(chalk2.red("Invalid JSON provided to --data"));
+        process.exit(1);
+      }
+      const instance = requireActiveInstance();
+      const client = new ServiceNowClient(instance);
+      const spinner = ora(`Creating record in ${table}...`).start();
+      try {
+        const record = await client.createRecord(table, data);
+        spinner.succeed(`Created sys_id: ${chalk2.green(record.sys_id)}`);
+        printRecords([record], opts.format);
+      } catch (err) {
+        spinner.fail();
+        console.error(chalk2.red(err instanceof Error ? err.message : String(err)));
+        process.exit(1);
+      }
+    }
+  );
+  cmd.command("update <table> <sys_id>").description("Update an existing record").requiredOption("-d, --data <json>", "JSON object of field values to update").option("--format <fmt>", "Output format: table or json", "json").action(
+    async (table, sysId, opts) => {
+      let data;
+      try {
+        data = JSON.parse(opts.data);
+      } catch {
+        console.error(chalk2.red("Invalid JSON provided to --data"));
+        process.exit(1);
+      }
+      const instance = requireActiveInstance();
+      const client = new ServiceNowClient(instance);
+      const spinner = ora(`Updating ${table}/${sysId}...`).start();
+      try {
+        const record = await client.updateRecord(table, sysId, data);
+        spinner.succeed("Record updated.");
+        printRecords([record], opts.format);
+      } catch (err) {
+        spinner.fail();
+        console.error(chalk2.red(err instanceof Error ? err.message : String(err)));
+        process.exit(1);
+      }
+    }
+  );
+  cmd.command("delete <table> <sys_id>").description("Delete a record").option("-y, --yes", "Skip confirmation prompt").action(async (table, sysId, opts) => {
+    if (!opts.yes) {
+      const { confirm: confirm2 } = await import("@inquirer/prompts");
+      const ok = await confirm2({
+        message: `Delete ${table}/${sysId}?`,
+        default: false
+      });
+      if (!ok) {
+        console.log("Aborted.");
+        return;
+      }
+    }
+    const instance = requireActiveInstance();
+    const client = new ServiceNowClient(instance);
+    const spinner = ora(`Deleting ${table}/${sysId}...`).start();
+    try {
+      await client.deleteRecord(table, sysId);
+      spinner.succeed(chalk2.green(`Deleted ${table}/${sysId}.`));
+    } catch (err) {
+      spinner.fail();
+      console.error(chalk2.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/schema.ts
+init_esm_shims();
+init_config();
+init_client();
+import { Command as Command3 } from "commander";
+import chalk3 from "chalk";
+import ora2 from "ora";
+function schemaCommand() {
+  return new Command3("schema").description("Retrieve the field schema for a ServiceNow table").argument("<table>", "Table name (e.g. incident, sys_user)").option("--format <fmt>", "Output format: table or json", "table").option("-f, --filter <text>", "Filter fields by name or label (case-insensitive)").action(
+    async (table, opts) => {
+      const instance = requireActiveInstance();
+      const client = new ServiceNowClient(instance);
+      const spinner = ora2(`Loading schema for ${table}...`).start();
+      try {
+        const res = await client.get(
+          "/api/now/table/sys_dictionary",
+          {
+            params: {
+              sysparm_query: `name=${table}^elementISNOTEMPTY`,
+              sysparm_fields: "element,column_label,internal_type,max_length,mandatory,read_only,reference,default_value,comments",
+              sysparm_display_value: "all",
+              sysparm_limit: 500,
+              sysparm_exclude_reference_link: true
+            }
+          }
+        );
+        spinner.stop();
+        let entries = res.result ?? [];
+        if (opts.filter) {
+          const filterLower = opts.filter.toLowerCase();
+          entries = entries.filter(
+            (e) => e.element?.value?.toLowerCase().includes(filterLower) || e.column_label?.display_value?.toLowerCase().includes(filterLower)
+          );
+        }
+        if (entries.length === 0) {
+          console.log(chalk3.dim(`No fields found for table "${table}".`));
+          return;
+        }
+        if (opts.format === "json") {
+          const mapped = entries.map((e) => ({
+            name: e.element?.value,
+            label: e.column_label?.display_value,
+            type: e.internal_type?.value,
+            maxLength: e.max_length?.value ? parseInt(e.max_length.value, 10) : void 0,
+            mandatory: e.mandatory?.value === "true",
+            readOnly: e.read_only?.value === "true",
+            reference: e.reference?.value || void 0,
+            defaultValue: e.default_value?.value || void 0,
+            comments: e.comments?.value || void 0
+          }));
+          console.log(JSON.stringify(mapped, null, 2));
+          return;
+        }
+        console.log(chalk3.bold(`
+Schema for ${chalk3.cyan(table)} (${entries.length} fields)
+`));
+        const colWidths = { name: 30, label: 30, type: 20, extra: 20 };
+        const header = [
+          "Field Name".padEnd(colWidths.name),
+          "Label".padEnd(colWidths.label),
+          "Type".padEnd(colWidths.type),
+          "Flags"
+        ].join("  ");
+        console.log(chalk3.bold(header));
+        console.log(chalk3.dim("-".repeat(header.length)));
+        for (const e of entries) {
+          const name = (e.element?.value ?? "").slice(0, colWidths.name).padEnd(colWidths.name);
+          const label = (e.column_label?.display_value ?? "").slice(0, colWidths.label).padEnd(colWidths.label);
+          const type = (e.internal_type?.value ?? "").slice(0, colWidths.type).padEnd(colWidths.type);
+          const flags = [];
+          if (e.mandatory?.value === "true") flags.push(chalk3.red("M"));
+          if (e.read_only?.value === "true") flags.push(chalk3.yellow("R"));
+          if (e.reference?.value) flags.push(chalk3.blue(`ref:${e.reference.value}`));
+          console.log(`${name}  ${label}  ${type}  ${flags.join(" ")}`);
+        }
+        console.log(chalk3.dim("\nFlags: M=mandatory  R=read-only  ref=reference table"));
+      } catch (err) {
+        spinner.fail();
+        console.error(chalk3.red(err instanceof Error ? err.message : String(err)));
+        process.exit(1);
+      }
+    }
+  );
+}
+
+// src/commands/script.ts
+init_esm_shims();
+init_config();
+init_client();
+import { Command as Command4 } from "commander";
+import { writeFileSync as writeFileSync2, readFileSync as readFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync2, readdirSync, statSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+import { spawnSync } from "child_process";
+import chalk4 from "chalk";
+import ora3 from "ora";
+function extensionForField(fieldName, fieldType) {
+  if (fieldType === "html" || fieldName.endsWith("_html")) return ".html";
+  if (fieldType === "css" || fieldName === "css") return ".css";
+  if (fieldType === "xml") return ".xml";
+  if (fieldType === "json") return ".json";
+  return ".js";
+}
+function resolveEditor(flag) {
+  if (flag) return flag;
+  if (process.env["VISUAL"]) return process.env["VISUAL"];
+  if (process.env["EDITOR"]) return process.env["EDITOR"];
+  const isWindows = process.platform === "win32";
+  const lookup = isWindows ? "where" : "which";
+  const candidates = isWindows ? ["code", "notepad++", "notepad"] : ["code", "nvim", "vim", "nano", "vi"];
+  for (const editor of candidates) {
+    const result = spawnSync(lookup, [editor], { encoding: "utf-8", shell: isWindows });
+    if (result.status === 0) return editor;
+  }
+  return isWindows ? "notepad" : "vi";
+}
+function scriptCommand() {
+  const cmd = new Command4("script").description(
+    "Download, edit, and push script fields to/from a ServiceNow instance"
+  );
+  cmd.command("pull <table> <sys_id> <field>").description("Download a script field to a local file and open it in an editor").option("-e, --editor <editor>", "Editor to open (default: $VISUAL / $EDITOR)").option("-o, --out <file>", "Save to a specific file path instead of a temp file").option("--no-open", "Download without opening the editor").action(
+    async (table, sysId, field, opts) => {
+      const instance = requireActiveInstance();
+      const client = new ServiceNowClient(instance);
+      const spinner = ora3(`Fetching ${table}/${sysId} field "${field}"...`).start();
+      let record;
+      try {
+        record = await client.getRecord(table, sysId, {
+          sysparmFields: `${field},sys_id,name,sys_name`
+        });
+        spinner.stop();
+      } catch (err) {
+        spinner.fail();
+        console.error(chalk4.red(err instanceof Error ? err.message : String(err)));
+        process.exit(1);
+      }
+      const content = String(record[field] ?? "");
+      let filePath;
+      if (opts.out) {
+        filePath = opts.out;
+      } else {
+        const dir = join2(homedir2(), ".snow", "scripts");
+        if (!existsSync2(dir)) mkdirSync2(dir, { recursive: true });
+        const safeName = `${table}_${sysId}_${field}`.replace(/[^a-z0-9_-]/gi, "_");
+        filePath = join2(dir, `${safeName}${extensionForField(field)}`);
+      }
+      writeFileSync2(filePath, content, "utf-8");
+      console.log(chalk4.green(`Saved to: ${filePath}`));
+      if (opts.open === false) return;
+      const editor = resolveEditor(opts.editor);
+      console.log(chalk4.dim(`Opening with: ${editor}`));
+      const result = spawnSync(editor, [filePath], {
+        stdio: "inherit",
+        shell: process.platform === "win32"
+      });
+      if (result.status !== 0) {
+        console.error(chalk4.red(`Editor exited with code ${result.status ?? "?"}`));
+        process.exit(result.status ?? 1);
+      }
+      const { confirm: confirm2 } = await import("@inquirer/prompts");
+      const shouldPush = await confirm2({
+        message: `Push changes to ${instance.alias}?`,
+        default: true
+      });
+      if (!shouldPush) {
+        console.log(chalk4.dim(`File kept at: ${filePath}`));
+        return;
+      }
+      await pushScript(client, table, sysId, field, filePath);
+    }
+  );
+  cmd.command("push <table> <sys_id> <field> [file]").description("Push a local file to a script field on the instance").action(async (table, sysId, field, file) => {
+    const instance = requireActiveInstance();
+    const client = new ServiceNowClient(instance);
+    let filePath;
+    if (file) {
+      filePath = file;
+    } else {
+      const dir = join2(homedir2(), ".snow", "scripts");
+      const safeName = `${table}_${sysId}_${field}`.replace(/[^a-z0-9_-]/gi, "_");
+      filePath = join2(dir, `${safeName}${extensionForField(field)}`);
+    }
+    if (!existsSync2(filePath)) {
+      console.error(chalk4.red(`File not found: ${filePath}`));
+      console.error(chalk4.dim("Run `snow script pull` first, or provide a file path."));
+      process.exit(1);
+    }
+    await pushScript(client, table, sysId, field, filePath);
+  });
+  cmd.command("list").alias("ls").description("List locally cached script files").action(() => {
+    const dir = join2(homedir2(), ".snow", "scripts");
+    if (!existsSync2(dir)) {
+      console.log(chalk4.dim("No scripts cached yet. Run `snow script pull` first."));
+      return;
+    }
+    const files = readdirSync(dir);
+    if (files.length === 0) {
+      console.log(chalk4.dim("No scripts cached."));
+      return;
+    }
+    for (const f of files) {
+      const stat = statSync(join2(dir, f));
+      const modified = stat.mtime.toLocaleString();
+      console.log(`${chalk4.cyan(f)}  ${chalk4.dim(modified)}`);
+    }
+  });
+  return cmd;
+}
+async function pushScript(client, table, sysId, field, filePath) {
+  const content = readFileSync2(filePath, "utf-8");
+  const spinner = ora3(`Pushing to ${table}/${sysId} field "${field}"...`).start();
+  try {
+    await client.updateRecord(table, sysId, { [field]: content });
+    spinner.succeed(chalk4.green(`Pushed successfully to ${table}/${sysId}.`));
+  } catch (err) {
+    spinner.fail();
+    console.error(chalk4.red(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+}
+
+// src/commands/provider.ts
+init_esm_shims();
+init_config();
+import { Command as Command5 } from "commander";
+import chalk5 from "chalk";
+import ora4 from "ora";
+
+// src/lib/llm.ts
+init_esm_shims();
+import axios2 from "axios";
+var OpenAIProvider = class {
+  constructor(apiKey, model, baseUrl = "https://api.openai.com/v1", name = "openai") {
+    this.apiKey = apiKey;
+    this.model = model;
+    this.baseUrl = baseUrl;
+    this.providerName = name;
+  }
+  providerName;
+  async complete(messages) {
+    const res = await axios2.post(
+      `${this.baseUrl.replace(/\/$/, "")}/chat/completions`,
+      { model: this.model, messages },
+      {
+        headers: {
+          Authorization: `Bearer ${this.apiKey}`,
+          "Content-Type": "application/json"
+        },
+        timeout: 12e4
+      }
+    );
+    const content = res.data.choices[0]?.message.content;
+    if (!content) throw new Error("LLM returned an empty response");
+    return content;
+  }
+};
+var AnthropicProvider = class {
+  constructor(apiKey, model) {
+    this.apiKey = apiKey;
+    this.model = model;
+  }
+  providerName = "anthropic";
+  async complete(messages) {
+    const system = messages.find((m) => m.role === "system")?.content;
+    const conversation = messages.filter((m) => m.role !== "system");
+    const res = await axios2.post(
+      "https://api.anthropic.com/v1/messages",
+      {
+        model: this.model,
+        max_tokens: 8192,
+        ...system ? { system } : {},
+        messages: conversation
+      },
+      {
+        headers: {
+          "x-api-key": this.apiKey,
+          "anthropic-version": "2023-06-01",
+          "Content-Type": "application/json"
+        },
+        timeout: 12e4
+      }
+    );
+    const text = res.data.content.find((c) => c.type === "text")?.text;
+    if (!text) throw new Error("Anthropic returned an empty response");
+    return text;
+  }
+};
+var OllamaProvider = class {
+  constructor(model, baseUrl = "http://localhost:11434") {
+    this.model = model;
+    this.baseUrl = baseUrl;
+  }
+  providerName = "ollama";
+  async complete(messages) {
+    const res = await axios2.post(
+      `${this.baseUrl.replace(/\/$/, "")}/api/chat`,
+      { model: this.model, messages, stream: false },
+      { headers: { "Content-Type": "application/json" }, timeout: 3e5 }
+    );
+    const content = res.data.message.content;
+    if (!content) throw new Error("Ollama returned an empty response");
+    return content;
+  }
+};
+function buildProvider(name, model, apiKey, baseUrl) {
+  switch (name) {
+    case "anthropic":
+      if (!apiKey) throw new Error("Anthropic provider requires an API key (https://platform.claude.com/)");
+      return new AnthropicProvider(apiKey, model);
+    case "xai":
+      if (!apiKey) throw new Error("xAI provider requires an API key (https://platform.x.ai/)");
+      return new OpenAIProvider(
+        apiKey,
+        model,
+        baseUrl ?? "https://api.x.ai/v1",
+        "xai"
+      );
+    case "ollama":
+      return new OllamaProvider(model, baseUrl);
+    case "openai":
+    default:
+      if (!apiKey) throw new Error("OpenAI provider requires an API key (https://platform.openai.com/)");
+      return new OpenAIProvider(apiKey, model, baseUrl, name);
+  }
+}
+function extractJSON(raw) {
+  const fenced = raw.match(/```(?:json)?\s*([\s\S]*?)```/);
+  if (fenced) return fenced[1].trim();
+  const start = raw.indexOf("{");
+  const end = raw.lastIndexOf("}");
+  if (start !== -1 && end !== -1) return raw.slice(start, end + 1);
+  return raw.trim();
+}
+
+// src/commands/provider.ts
+var PROVIDER_NAMES = ["openai", "anthropic", "xai", "ollama"];
+var PROVIDER_DEFAULTS = {
+  openai: { model: "gpt-4o" },
+  anthropic: { model: "claude-opus-4-6" },
+  xai: { model: "grok-3", baseUrl: "https://api.x.ai/v1" },
+  ollama: { model: "llama3", baseUrl: "http://localhost:11434" }
+};
+function providerCommand() {
+  const cmd = new Command5("provider").description(
+    "Configure LLM providers for AI-powered ServiceNow app generation"
+  );
+  cmd.command("list").alias("ls").description("List configured LLM providers").action(() => {
+    const ai = getAIConfig();
+    const configured = Object.entries(ai.providers);
+    if (configured.length === 0) {
+      console.log(chalk5.dim("No providers configured. Run `snow provider set <name>` to add one."));
+      console.log();
+      console.log(chalk5.bold("Available providers:"));
+      for (const name of PROVIDER_NAMES) {
+        const d = PROVIDER_DEFAULTS[name];
+        console.log(`  ${chalk5.cyan(name.padEnd(12))} default model: ${chalk5.dim(d.model)}`);
+      }
+      return;
+    }
+    console.log(chalk5.bold("Configured providers:"));
+    for (const [name, config] of configured) {
+      const isActive = ai.activeProvider === name;
+      const marker = isActive ? chalk5.green("\u2714 ") : "  ";
+      const keyDisplay = config.apiKey ? chalk5.dim("key: " + config.apiKey.slice(0, 8) + "\u2026") : chalk5.dim("(no key \u2014 local)");
+      const urlDisplay = config.baseUrl ? chalk5.dim(` @ ${config.baseUrl}`) : "";
+      console.log(`${marker}${chalk5.cyan(name.padEnd(12))} ${config.model}  ${keyDisplay}${urlDisplay}`);
+    }
+    if (ai.activeProvider) {
+      console.log();
+      console.log(chalk5.dim(`Active: ${ai.activeProvider}`));
+    }
+  });
+  cmd.command("set <name>").description("Add or update an LLM provider configuration").option("-k, --key <apiKey>", "API key (not required for ollama)").option("-m, --model <model>", "Model name to use").option("-u, --url <baseUrl>", "Custom base URL (for ollama or self-hosted endpoints)").action(
+    async (name, opts) => {
+      if (!PROVIDER_NAMES.includes(name)) {
+        console.error(
+          chalk5.red(`Unknown provider: ${name}. Choose from: ${PROVIDER_NAMES.join(", ")}`)
+        );
+        process.exit(1);
+      }
+      const providerName = name;
+      const defaults = PROVIDER_DEFAULTS[providerName];
+      let apiKey = opts.key;
+      let model = opts.model ?? defaults.model;
+      let baseUrl = opts.url ?? defaults.baseUrl;
+      if (providerName !== "ollama" && !apiKey) {
+        const { input: input2, password: password2 } = await import("@inquirer/prompts");
+        apiKey = await password2({ message: `${name} API key:` });
+        if (!opts.model) {
+          model = await input2({
+            message: `Model (default: ${defaults.model}):`,
+            default: defaults.model
+          });
+        }
+      }
+      setProviderConfig(providerName, {
+        model,
+        ...apiKey ? { apiKey } : {},
+        ...baseUrl ? { baseUrl } : {}
+      });
+      console.log(chalk5.green(`\u2714 Provider "${name}" configured (model: ${model})`));
+      const ai = getAIConfig();
+      if (ai.activeProvider === providerName) {
+        console.log(chalk5.dim("This is now the active provider."));
+      } else {
+        console.log(chalk5.dim(`Run \`snow provider use ${name}\` to activate it.`));
+      }
+    }
+  );
+  cmd.command("use <name>").description("Set the active LLM provider").action((name) => {
+    if (!PROVIDER_NAMES.includes(name)) {
+      console.error(chalk5.red(`Unknown provider: ${name}`));
+      process.exit(1);
+    }
+    const ok = setActiveProvider(name);
+    if (!ok) {
+      console.error(chalk5.red(`Provider "${name}" is not configured. Run \`snow provider set ${name}\` first.`));
+      process.exit(1);
+    }
+    console.log(chalk5.green(`\u2714 Active provider set to: ${name}`));
+  });
+  cmd.command("remove <name>").alias("rm").description("Remove a provider configuration").action((name) => {
+    const ok = removeProviderConfig(name);
+    if (!ok) {
+      console.error(chalk5.yellow(`Provider "${name}" was not configured.`));
+      process.exit(1);
+    }
+    console.log(chalk5.green(`\u2714 Removed provider: ${name}`));
+  });
+  cmd.command("test [name]").description("Send a test message to verify provider connectivity").action(async (name) => {
+    let providerName;
+    let config;
+    if (name) {
+      const ai = getAIConfig();
+      const stored = ai.providers[name];
+      if (!stored) {
+        console.error(chalk5.red(`Provider "${name}" is not configured.`));
+        process.exit(1);
+      }
+      providerName = name;
+      config = stored;
+    } else {
+      const active = getActiveProvider();
+      if (!active) {
+        console.error(chalk5.red("No active provider configured. Run `snow provider set <name>`."));
+        process.exit(1);
+      }
+      providerName = active.name;
+      config = active.config;
+    }
+    const spinner = ora4(`Testing ${providerName} (${config.model})\u2026`).start();
+    try {
+      const provider = buildProvider(providerName, config.model, config.apiKey, config.baseUrl);
+      const response = await provider.complete([
+        { role: "user", content: 'Reply with exactly: "snow-cli connection OK"' }
+      ]);
+      spinner.succeed(chalk5.green(`${providerName} responded: ${response.trim()}`));
+    } catch (err) {
+      spinner.fail(chalk5.red(`Connection failed: ${err instanceof Error ? err.message : String(err)}`));
+      process.exit(1);
+    }
+  });
+  cmd.command("show").description("Show the active provider configuration").action(() => {
+    const active = getActiveProvider();
+    if (!active) {
+      console.log(chalk5.dim("No active provider. Run `snow provider set <name>`."));
+      return;
+    }
+    console.log(chalk5.bold("Active provider:"));
+    console.log(`  Name:    ${chalk5.cyan(active.name)}`);
+    console.log(`  Model:   ${active.config.model}`);
+    if (active.config.baseUrl) {
+      console.log(`  URL:     ${chalk5.dim(active.config.baseUrl)}`);
+    }
+    if (active.config.apiKey) {
+      console.log(`  API Key: ${chalk5.dim(active.config.apiKey.slice(0, 8) + "\u2026")}`);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/ai.ts
+init_esm_shims();
+init_config();
+import { Command as Command6 } from "commander";
+import * as readline from "readline";
+import { writeFileSync as writeFileSync3, readFileSync as readFileSync3, existsSync as existsSync3, mkdirSync as mkdirSync3, readdirSync as readdirSync2 } from "fs";
+import { join as join3, dirname, basename } from "path";
+import { tmpdir as tmpdir2 } from "os";
+import { spawnSync as spawnSync2 } from "child_process";
+import chalk6 from "chalk";
+import ora5 from "ora";
+
+// src/lib/sn-context.ts
+init_esm_shims();
+var SN_SYSTEM_PROMPT = `
+You are an expert ServiceNow developer. Your task is to generate ServiceNow application artifacts based on user requirements.
+
+## Response Format
+
+You MUST respond with a single JSON object (optionally wrapped in a \`\`\`json code fence). Do not include any explanation outside the JSON.
+
+Schema:
+\`\`\`json
+{
+  "name": "Human-readable update set name",
+  "description": "What this application/feature does",
+  "scope": { ... },
+  "artifacts": [
+    {
+      "type": "<artifact_type>",
+      "fields": { ... type-specific fields ... }
+    }
+  ]
+}
+\`\`\`
+
+The "scope" key is optional \u2014 see the Scoped Applications section below.
+
+---
+
+## Scoped Applications
+
+Add a "scope" object to the root of your JSON response when the request:
+- Creates 2 or more custom tables
+- Is described as an "application", "module", or "package"
+- Needs a distinct namespace to avoid naming conflicts with OOTB or other customisations
+
+Do NOT add a scope for:
+- Business rules, client scripts, or script includes that customise existing OOTB tables
+- Simple standalone features that don't require custom tables
+
+Scope object format:
+\`\`\`json
+"scope": {
+  "prefix": "x_myco_myapp",
+  "name":   "My Application Name",
+  "version": "1.0.0",
+  "vendor": "My Company"
+}
+\`\`\`
+
+Prefix rules: must match \`x_<vendor_abbrev>_<app_abbrev>\`, all lowercase, underscores only.
+
+When scope is set:
+- All custom **table names** MUST be prefixed: \`{prefix}_tablename\`
+- Script include **api_name** MUST be prefixed: \`{prefix}.ClassName\`
+- Business rules, client scripts, and other artifacts reference the prefixed table name in their "table" field
+
+---
+
+## Artifact Types
+
+### script_include
+Server-side reusable JavaScript class. Referenced by other server-side scripts.
+
+Fields:
+- name (string, required) \u2014 PascalCase class name, e.g. "IncidentUtils"
+- api_name (string, required) \u2014 same as name; if scoped: "{prefix}.ClassName"
+- description (string)
+- script (string, required) \u2014 full script body (see patterns below)
+- client_callable (boolean) \u2014 true only if called via GlideAjax from a client script
+- active (boolean, default: true)
+
+Script pattern (standard):
+\`\`\`javascript
+var ClassName = Class.create();
+ClassName.prototype = {
+    initialize: function(param) {
+        this.param = param;
+    },
+    methodName: function() {
+        var gr = new GlideRecord('table_name');
+        gr.addQuery('field', 'value');
+        gr.query();
+        while (gr.next()) {
+            // process records
+        }
+        return result;
+    },
+    type: 'ClassName'
+};
+\`\`\`
+
+Client-callable (GlideAjax) pattern:
+\`\`\`javascript
+var ClassName = Class.create();
+ClassName.prototype = Object.extendsObject(AbstractAjaxProcessor, {
+    methodName: function() {
+        var param = this.getParameter('sysparm_param');
+        return result;
+    },
+    type: 'ClassName'
+});
+\`\`\`
+
+---
+
+### business_rule
+Server-side script that executes automatically on database operations.
+
+Fields:
+- name (string, required)
+- description (string)
+- table (string, required) \u2014 table name, e.g. "incident", "x_myco_myapp_request"
+- when (string, required) \u2014 "before" | "after" | "async" | "display"
+- order (number, default: 100)
+- active (boolean, default: true)
+- action_insert (boolean) \u2014 fire on INSERT
+- action_update (boolean) \u2014 fire on UPDATE
+- action_delete (boolean) \u2014 fire on DELETE
+- action_query (boolean) \u2014 fire on SELECT (display rules only)
+- condition (string) \u2014 GlideRecord condition expression
+- script (string, required)
+
+Script pattern:
+\`\`\`javascript
+(function executeRule(current, previous /*null when async*/) {
+    gs.log('Rule fired: ' + current.getDisplayValue(), 'source');
+    current.setValue('field_name', 'new_value');
+    // For before rules do NOT call current.update()
+})(current, previous);
+\`\`\`
+
+---
+
+### client_script
+JavaScript that runs in the user's browser on ServiceNow forms.
+
+Fields:
+- name (string, required)
+- description (string)
+- table (string, required)
+- type (string, required) \u2014 "onLoad" | "onChange" | "onSubmit" | "onCellEdit"
+- field_name (string) \u2014 required when type is "onChange" or "onCellEdit"
+- active (boolean, default: true)
+- script (string, required)
+
+Script patterns:
+\`\`\`javascript
+// onLoad
+function onLoad() {
+    g_form.setMandatory('field_name', true);
+}
+
+// onChange
+function onChange(control, oldValue, newValue, isLoading, isTemplate) {
+    if (isLoading || newValue === '') return;
+    g_form.setMandatory('other_field', newValue === 'specific_value');
+}
+
+// onSubmit
+function onSubmit() {
+    if (!g_form.getValue('field_name')) {
+        g_form.addErrorMessage('Field is required.');
+        return false;
+    }
+    return true;
+}
+\`\`\`
+
+Available client globals: g_form, g_user, g_list, g_menu, NOW
+
+---
+
+### ui_action
+A button, context menu item, or link on a form or list.
+
+Fields:
+- name (string, required)
+- description (string)
+- table (string, required)
+- action_name (string, required) \u2014 unique identifier, snake_case
+- active (boolean, default: true)
+- client (boolean) \u2014 true if onclick runs client-side
+- form_button (boolean)
+- form_context_menu (boolean)
+- list_action (boolean)
+- condition (string)
+- onclick (string) \u2014 client-side JS (if client: true)
+- script (string) \u2014 server-side script (if client: false)
+
+Server-side script pattern:
+\`\`\`javascript
+(function() {
+    current.setValue('state', '3');
+    current.update();
+    action.setRedirectURL(current);
+})();
+\`\`\`
+
+---
+
+### ui_page
+A full HTML page served by ServiceNow.
+
+Fields:
+- name (string, required) \u2014 URL-safe name, path: /{name}.do
+- description (string)
+- html (string, required) \u2014 full HTML with Jelly templating
+- client_script (string) \u2014 client-side JavaScript (runs in the browser)
+- processing_script (string) \u2014 server-side JavaScript (runs before the page renders)
+- direct (boolean, default: false) \u2014 allow direct URL access without authentication
+- category (string, default: "general")
+
+HTML template example:
+\`\`\`html
+<?xml version="1.0" encoding="utf-8" ?>
+<j:jelly trim="false" xmlns:j="jelly:core" xmlns:g="glide" xmlns:j2="null" xmlns:g2="null">
+  <g:evaluate var="jvar_result" expression="new MyScriptInclude().getData();" />
+  <div id="main">
+    <h2>Page Title</h2>
+    <p>\${jvar_result}</p>
+  </div>
+</j:jelly>
+\`\`\`
+
+---
+
+### scheduled_job
+A script that runs on a schedule.
+
+Fields:
+- name (string, required)
+- description (string)
+- active (boolean, default: true)
+- run_type (string, required) \u2014 "daily" | "weekly" | "monthly" | "periodically" | "once"
+- run_time (string) \u2014 time of day, e.g. "03:00:00"
+- run_period (string) \u2014 interval for periodically, e.g. "00:30:00"
+- run_dayofweek (string) \u2014 for weekly: "1"=Sun \u2026 "7"=Sat
+- run_dayofmonth (string) \u2014 for monthly: "1"\u2013"31"
+- script (string, required)
+
+Script pattern:
+\`\`\`javascript
+(function runJob() {
+    var gr = new GlideRecord('table_name');
+    gr.addQuery('state', 'open');
+    gr.query();
+    while (gr.next()) {
+        gs.log('Processed: ' + gr.sys_id, 'ScheduledJob');
+    }
+})();
+\`\`\`
+
+---
+
+### table
+A custom database table with fields. Generates sys_db_object + sys_dictionary entries.
+
+Fields:
+- name (string, required) \u2014 table name; MUST be prefixed if scoped: "{prefix}_tablename"
+- label (string, required) \u2014 singular display label, e.g. "Asset Request"
+- plural (string) \u2014 plural label, e.g. "Asset Requests"
+- extends (string) \u2014 parent table to extend, e.g. "task" for task-based tables
+- is_extendable (boolean, default: false)
+- columns (array, required) \u2014 list of column definitions (see below)
+
+Column definition:
+\`\`\`json
+{
+  "element": "u_field_name",
+  "label": "Field Label",
+  "internal_type": "string",
+  "max_length": 255,
+  "mandatory": false,
+  "default_value": "",
+  "reference": "sys_user"
+}
+\`\`\`
+
+Valid internal_type values: string, integer, boolean, reference, glide_date_time, glide_date,
+float, decimal, html, url, email, phone_number, choice, sys_class_name
+
+For choice fields add a "choices" array:
+\`\`\`json
+{
+  "element": "u_status",
+  "label": "Status",
+  "internal_type": "choice",
+  "choices": [
+    { "value": "draft",    "label": "Draft" },
+    { "value": "pending",  "label": "Pending Approval" },
+    { "value": "approved", "label": "Approved" },
+    { "value": "rejected", "label": "Rejected" }
+  ]
+}
+\`\`\`
+
+Note: if the table extends "task", standard fields (number, state, priority, assigned_to,
+short_description, etc.) are inherited \u2014 do not re-declare them as columns.
+
+---
+
+### decision_table
+A Decision Table that maps sets of input conditions to an output result.
+Generates sys_decision + sys_decision_question + sys_decision_case + sys_decision_case_question records.
+
+Fields:
+- name (string, required) \u2014 unique snake_case identifier
+- label (string, required) \u2014 human-readable table name
+- description (string)
+- inputs (array, required) \u2014 input column definitions
+- output_label (string, required) \u2014 label for the result column, e.g. "Priority"
+- output_type (string) \u2014 type of the output value: "string" (default) | "integer" | "reference"
+- rules (array, required) \u2014 ordered list of rules (evaluated top-down, first match wins)
+
+Input definition:
+\`\`\`json
+{ "name": "urgency", "label": "Urgency", "type": "string" }
+\`\`\`
+
+Rule definition:
+\`\`\`json
+{
+  "label": "Critical \u2014 P1",
+  "conditions": [
+    { "input": "urgency", "operator": "=", "value": "1" },
+    { "input": "impact",  "operator": "=", "value": "1" }
+  ],
+  "result": "1"
+}
+\`\`\`
+
+Valid operators: = | != | > | >= | < | <= | starts_with | contains | is_empty | is_not_empty
+
+Full example:
+\`\`\`json
+{
+  "type": "decision_table",
+  "fields": {
+    "name": "incident_priority_matrix",
+    "label": "Incident Priority Matrix",
+    "inputs": [
+      { "name": "urgency", "label": "Urgency", "type": "string" },
+      { "name": "impact",  "label": "Impact",  "type": "string" }
+    ],
+    "output_label": "Priority",
+    "output_type": "string",
+    "rules": [
+      { "label": "P1 Critical", "conditions": [{"input":"urgency","operator":"=","value":"1"},{"input":"impact","operator":"=","value":"1"}], "result": "1" },
+      { "label": "P2 High",     "conditions": [{"input":"urgency","operator":"=","value":"1"},{"input":"impact","operator":"=","value":"2"}], "result": "2" },
+      { "label": "P3 Moderate", "conditions": [{"input":"urgency","operator":"=","value":"2"},{"input":"impact","operator":"=","value":"2"}], "result": "3" }
+    ]
+  }
+}
+\`\`\`
+
+---
+
+### flow_action
+A reusable Custom Action for Flow Designer.
+Generates sys_hub_action_type_definition + sys_hub_action_input + sys_hub_action_output records.
+
+Fields:
+- name (string, required) \u2014 unique snake_case identifier
+- label (string, required) \u2014 display name shown in Flow Designer action picker
+- description (string)
+- category (string) \u2014 category grouping in the picker, e.g. "Incident Management"
+- script (string, required) \u2014 action body (see pattern below)
+- active (boolean, default: true)
+- inputs (array) \u2014 input variable definitions
+- outputs (array) \u2014 output variable definitions
+
+Input/output definition:
+\`\`\`json
+{ "name": "incident_sys_id", "label": "Incident Sys ID", "type": "string", "mandatory": true }
+\`\`\`
+
+Valid types for inputs/outputs: string, integer, boolean, reference, glide_date_time, script
+
+Script pattern \u2014 inputs and outputs are available as plain objects:
+\`\`\`javascript
+(function execute(inputs, outputs) {
+    var gr = new GlideRecord('incident');
+    gr.initialize();
+    gr.setValue('short_description', inputs.short_description);
+    gr.setValue('category', inputs.category || 'inquiry');
+    var sysId = gr.insert();
+    outputs.incident_sys_id = sysId;
+    outputs.success = (sysId !== null && sysId !== '');
+})(inputs, outputs);
+\`\`\`
+
+Full example:
+\`\`\`json
+{
+  "type": "flow_action",
+  "fields": {
+    "name": "create_incident_action",
+    "label": "Create Incident",
+    "description": "Creates an incident record and returns its sys_id",
+    "category": "Incident Management",
+    "inputs": [
+      { "name": "short_description", "label": "Short Description", "type": "string", "mandatory": true },
+      { "name": "category",          "label": "Category",          "type": "string" },
+      { "name": "urgency",           "label": "Urgency",           "type": "string" }
+    ],
+    "outputs": [
+      { "name": "incident_sys_id", "label": "Incident Sys ID", "type": "string" },
+      { "name": "success",         "label": "Success",         "type": "boolean" }
+    ],
+    "script": "(function execute(inputs, outputs) { ... })(inputs, outputs);"
+  }
+}
+\`\`\`
+
+---
+
+## ServiceNow Server-Side API Reference
+
+### GlideRecord
+\`\`\`javascript
+var gr = new GlideRecord('incident');
+gr.addQuery('active', true);
+gr.addEncodedQuery('state=1^urgency=2');
+gr.orderBy('sys_created_on');
+gr.setLimit(100);
+gr.query();
+while (gr.next()) {
+    var id  = gr.sys_id.toString();
+    var val = gr.getValue('short_description');
+    var disp = gr.getDisplayValue('assigned_to');
+}
+
+var newGr = new GlideRecord('incident');
+newGr.initialize();
+newGr.setValue('short_description', 'New incident');
+var sysId = newGr.insert();
+
+gr.setValue('state', '2');
+gr.update();
+
+gr.deleteRecord();
+
+var rec = new GlideRecord('incident');
+if (rec.get(sysId)) { /* found */ }
+\`\`\`
+
+### GlideSystem (gs)
+\`\`\`javascript
+gs.log('message', 'source');
+gs.info('message');
+gs.warn('message');
+gs.error('message');
+gs.getUserID();
+gs.getUserName();
+gs.getUser().getFullName();
+gs.hasRole('admin');
+gs.now();            // YYYY-MM-DD
+gs.nowDateTime();    // YYYY-MM-DD HH:MM:SS
+gs.setProperty('prop.name', 'value');
+gs.getProperty('prop.name', 'default');
+\`\`\`
+
+### GlideDateTime
+\`\`\`javascript
+var gdt = new GlideDateTime();
+gdt.addDays(5);
+gdt.addSeconds(3600);
+var iso  = gdt.getValue();
+var disp = gdt.getDisplayValue();
+\`\`\`
+
+---
+
+## Important Rules
+
+1. All scripts must be valid ES5 JavaScript \u2014 no arrow functions, no const/let in server scripts, use var.
+2. Business rules: use "before" for validation/field manipulation; "async" for integrations and heavy operations.
+3. Never use synchronous XMLHttpRequest in client scripts \u2014 use GlideAjax or REST Message.
+4. Script includes should be stateless where possible; store state in the constructor only.
+5. Always handle the case where GlideRecord queries return no results.
+6. Generate realistic, working code \u2014 not stubs or placeholders.
+7. sys_id values in artifacts will be auto-generated; do not include them.
+8. For decision tables, generate a rule for every meaningful input combination; put the most specific rules first.
+9. For flow actions, the script MUST use the (function execute(inputs, outputs) { ... })(inputs, outputs) wrapper \u2014 do not use GlideScriptedExtensionPoint patterns.
+
+---
+
+## Interaction Mode
+
+### Conversational mode (plain text)
+Use this when you need clarification before generating. Ask targeted questions about:
+- Which table(s) the feature operates on
+- Whether a scoped application is needed (if ambiguous)
+- Specific field names, reference fields, or lookup values
+- Business logic conditions or edge cases
+- Whether the operation should be client-side, server-side, or both
+
+Respond in plain conversational text. Do NOT wrap in JSON.
+
+### Build mode (JSON only)
+Once you have enough information, respond with ONLY the JSON object wrapped in a \`\`\`json code fence \u2014 no prose before or after it.
+
+**On refinement requests**: Always output the COMPLETE updated artifact list, not just the changed artifact. The CLI replaces the entire build on each JSON response.
+
+**Decide based on clarity**:
+- Clear, specific request \u2192 go straight to Build mode
+- Vague or ambiguous request \u2192 ask 1\u20133 focused questions first, then build
+`.trim();
+var ARTIFACT_REQUIRED_FIELDS = {
+  script_include: ["name", "api_name", "script"],
+  business_rule: ["name", "table", "when", "script"],
+  client_script: ["name", "table", "type", "script"],
+  ui_action: ["name", "table", "action_name"],
+  ui_page: ["name", "html"],
+  scheduled_job: ["name", "run_type", "script"],
+  table: ["name", "label", "columns"],
+  decision_table: ["name", "label", "inputs", "output_label", "rules"],
+  flow_action: ["name", "label", "script"]
+};
+var ARTIFACT_TABLE = {
+  script_include: "sys_script_include",
+  business_rule: "sys_script",
+  client_script: "sys_client_script",
+  ui_action: "sys_ui_action",
+  ui_page: "sys_ui_page",
+  scheduled_job: "sys_trigger"
+};
+var ARTIFACT_LABEL = {
+  script_include: "Script Include",
+  business_rule: "Business Rule",
+  client_script: "Client Script",
+  ui_action: "UI Action",
+  ui_page: "UI Page",
+  scheduled_job: "Scheduled Script Execution",
+  table: "Table",
+  decision_table: "Decision Table",
+  flow_action: "Flow Action"
+};
+
+// src/lib/update-set.ts
+init_esm_shims();
+import { randomUUID } from "crypto";
+function validateBuild(build) {
+  const errors = [];
+  for (let i = 0; i < build.artifacts.length; i++) {
+    const artifact = build.artifacts[i];
+    const required = ARTIFACT_REQUIRED_FIELDS[artifact.type] ?? [];
+    const missing = required.filter(
+      (f) => artifact.fields[f] === void 0 || artifact.fields[f] === "" || artifact.fields[f] === null
+    );
+    if (missing.length > 0) {
+      errors.push({
+        artifactIndex: i,
+        type: artifact.type,
+        name: String(artifact.fields["name"] ?? "(unnamed)"),
+        missing
+      });
+    }
+  }
+  return errors;
+}
+function expandSimple(artifact, scopeSysId) {
+  const table = ARTIFACT_TABLE[artifact.type];
+  if (!table) return [];
+  const sysId = randomUUID().replace(/-/g, "");
+  const fields = {
+    ...artifact.fields,
+    active: artifact.fields["active"] !== false ? "true" : "false"
+  };
+  if (scopeSysId) {
+    fields["sys_scope"] = scopeSysId;
+    fields["sys_package"] = scopeSysId;
+  }
+  return [{ table, sysId, label: ARTIFACT_LABEL[artifact.type] ?? artifact.type, fields }];
+}
+function expandTable(artifact, scopeSysId) {
+  const records = [];
+  const tableSysId = randomUUID().replace(/-/g, "");
+  const tableName = String(artifact.fields["name"] ?? "");
+  const dbObjFields = {
+    name: tableName,
+    label: String(artifact.fields["label"] ?? tableName),
+    plural: String(artifact.fields["plural"] ?? String(artifact.fields["label"] ?? tableName) + "s"),
+    is_extendable: artifact.fields["is_extendable"] ? "true" : "false",
+    create_access: "true",
+    read_access: "true",
+    write_access: "true",
+    delete_access: "true"
+  };
+  if (artifact.fields["extends"]) dbObjFields["super_class"] = String(artifact.fields["extends"]);
+  if (scopeSysId) {
+    dbObjFields["sys_scope"] = scopeSysId;
+    dbObjFields["sys_package"] = scopeSysId;
+  }
+  records.push({ table: "sys_db_object", sysId: tableSysId, label: "Table", fields: dbObjFields });
+  const columns = Array.isArray(artifact.fields["columns"]) ? artifact.fields["columns"] : [];
+  for (const col of columns) {
+    const dictSysId = randomUUID().replace(/-/g, "");
+    const isChoice = String(col["internal_type"] ?? "") === "choice";
+    const dictFields = {
+      name: tableName,
+      element: String(col["element"] ?? ""),
+      column_label: String(col["label"] ?? col["element"] ?? ""),
+      internal_type: isChoice ? "string" : String(col["internal_type"] ?? "string"),
+      max_length: col["max_length"] ?? (isChoice || String(col["internal_type"]) === "string" ? 255 : ""),
+      mandatory: col["mandatory"] ? "true" : "false",
+      active: "true"
+    };
+    if (col["default_value"] !== void 0) dictFields["default_value"] = String(col["default_value"]);
+    if (col["reference"]) dictFields["reference"] = String(col["reference"]);
+    if (isChoice) dictFields["choice"] = "1";
+    if (scopeSysId) {
+      dictFields["sys_scope"] = scopeSysId;
+      dictFields["sys_package"] = scopeSysId;
+    }
+    records.push({ table: "sys_dictionary", sysId: dictSysId, label: "Field", fields: dictFields });
+    if (isChoice && Array.isArray(col["choices"])) {
+      const choices = col["choices"];
+      for (let ci = 0; ci < choices.length; ci++) {
+        const ch = choices[ci];
+        const choiceVal = typeof ch === "object" ? String(ch["value"] ?? "") : String(ch).toLowerCase().replace(/\s+/g, "_");
+        const choiceLabel = typeof ch === "object" ? String(ch["label"] ?? ch["value"] ?? "") : String(ch);
+        const choiceSysId = randomUUID().replace(/-/g, "");
+        const choiceFields = {
+          name: tableName,
+          element: String(col["element"] ?? ""),
+          value: choiceVal,
+          label: choiceLabel,
+          sequence: ci * 100,
+          inactive: "false"
+        };
+        if (scopeSysId) {
+          choiceFields["sys_scope"] = scopeSysId;
+          choiceFields["sys_package"] = scopeSysId;
+        }
+        records.push({ table: "sys_choice", sysId: choiceSysId, label: "Choice", fields: choiceFields });
+      }
+    }
+  }
+  return records;
+}
+function expandDecisionTable(artifact, scopeSysId) {
+  const records = [];
+  const decisionSysId = randomUUID().replace(/-/g, "");
+  const baseFields = {
+    name: String(artifact.fields["name"] ?? ""),
+    label: String(artifact.fields["label"] ?? artifact.fields["name"] ?? ""),
+    description: String(artifact.fields["description"] ?? ""),
+    active: "true"
+  };
+  if (scopeSysId) {
+    baseFields["sys_scope"] = scopeSysId;
+    baseFields["sys_package"] = scopeSysId;
+  }
+  records.push({ table: "sys_decision", sysId: decisionSysId, label: "Decision Table", fields: baseFields });
+  const inputs = Array.isArray(artifact.fields["inputs"]) ? artifact.fields["inputs"] : [];
+  const inputSysIds = {};
+  for (let i = 0; i < inputs.length; i++) {
+    const inp = inputs[i];
+    const inpSysId = randomUUID().replace(/-/g, "");
+    const inpName = String(inp["name"] ?? inp["field"] ?? `input_${i}`);
+    inputSysIds[inpName] = inpSysId;
+    const qFields = {
+      decision: decisionSysId,
+      label: String(inp["label"] ?? inpName),
+      order: i * 100,
+      question_type: String(inp["type"] ?? "string")
+    };
+    if (inp["reference"]) qFields["reference_table"] = String(inp["reference"]);
+    if (scopeSysId) {
+      qFields["sys_scope"] = scopeSysId;
+      qFields["sys_package"] = scopeSysId;
+    }
+    records.push({ table: "sys_decision_question", sysId: inpSysId, label: "Decision Input", fields: qFields });
+  }
+  const rules = Array.isArray(artifact.fields["rules"]) ? artifact.fields["rules"] : [];
+  for (let ri = 0; ri < rules.length; ri++) {
+    const rule = rules[ri];
+    const caseSysId = randomUUID().replace(/-/g, "");
+    const caseFields = {
+      decision: decisionSysId,
+      label: String(rule["label"] ?? `Rule ${ri + 1}`),
+      order: ri * 100,
+      result: String(rule["result"] ?? "")
+    };
+    if (scopeSysId) {
+      caseFields["sys_scope"] = scopeSysId;
+      caseFields["sys_package"] = scopeSysId;
+    }
+    records.push({ table: "sys_decision_case", sysId: caseSysId, label: "Decision Rule", fields: caseFields });
+    const conditions = Array.isArray(rule["conditions"]) ? rule["conditions"] : [];
+    for (const cond of conditions) {
+      const condSysId = randomUUID().replace(/-/g, "");
+      const inputName = String(cond["input"] ?? "");
+      const cqFields = {
+        case: caseSysId,
+        question: inputSysIds[inputName] ?? "",
+        operator: String(cond["operator"] ?? "="),
+        value: String(cond["value"] ?? "")
+      };
+      if (scopeSysId) {
+        cqFields["sys_scope"] = scopeSysId;
+        cqFields["sys_package"] = scopeSysId;
+      }
+      records.push({ table: "sys_decision_case_question", sysId: condSysId, label: "Decision Condition", fields: cqFields });
+    }
+  }
+  return records;
+}
+function expandFlowAction(artifact, scopeSysId) {
+  const records = [];
+  const actionSysId = randomUUID().replace(/-/g, "");
+  const actionFields = {
+    name: String(artifact.fields["name"] ?? ""),
+    label: String(artifact.fields["label"] ?? artifact.fields["name"] ?? ""),
+    description: String(artifact.fields["description"] ?? ""),
+    category: String(artifact.fields["category"] ?? "Custom"),
+    script: String(artifact.fields["script"] ?? ""),
+    active: artifact.fields["active"] !== false ? "true" : "false"
+  };
+  if (scopeSysId) {
+    actionFields["sys_scope"] = scopeSysId;
+    actionFields["sys_package"] = scopeSysId;
+  }
+  records.push({ table: "sys_hub_action_type_definition", sysId: actionSysId, label: "Flow Action", fields: actionFields });
+  const inputs = Array.isArray(artifact.fields["inputs"]) ? artifact.fields["inputs"] : [];
+  for (let i = 0; i < inputs.length; i++) {
+    const inp = inputs[i];
+    const inpSysId = randomUUID().replace(/-/g, "");
+    const inpFields = {
+      action_type: actionSysId,
+      name: String(inp["name"] ?? `input_${i}`),
+      label: String(inp["label"] ?? inp["name"] ?? `Input ${i + 1}`),
+      type: String(inp["type"] ?? "string"),
+      mandatory: inp["mandatory"] ? "true" : "false",
+      order: i * 100
+    };
+    if (scopeSysId) {
+      inpFields["sys_scope"] = scopeSysId;
+      inpFields["sys_package"] = scopeSysId;
+    }
+    records.push({ table: "sys_hub_action_input", sysId: inpSysId, label: "Action Input", fields: inpFields });
+  }
+  const outputs = Array.isArray(artifact.fields["outputs"]) ? artifact.fields["outputs"] : [];
+  for (let i = 0; i < outputs.length; i++) {
+    const out = outputs[i];
+    const outSysId = randomUUID().replace(/-/g, "");
+    const outFields = {
+      action_type: actionSysId,
+      name: String(out["name"] ?? `output_${i}`),
+      label: String(out["label"] ?? out["name"] ?? `Output ${i + 1}`),
+      type: String(out["type"] ?? "string"),
+      order: i * 100
+    };
+    if (scopeSysId) {
+      outFields["sys_scope"] = scopeSysId;
+      outFields["sys_package"] = scopeSysId;
+    }
+    records.push({ table: "sys_hub_action_output", sysId: outSysId, label: "Action Output", fields: outFields });
+  }
+  return records;
+}
+function expandArtifact(artifact, scopeSysId) {
+  switch (artifact.type) {
+    case "table":
+      return expandTable(artifact, scopeSysId);
+    case "decision_table":
+      return expandDecisionTable(artifact, scopeSysId);
+    case "flow_action":
+      return expandFlowAction(artifact, scopeSysId);
+    default:
+      return expandSimple(artifact, scopeSysId);
+  }
+}
+function buildScopeRecord(scope, scopeSysId) {
+  return {
+    table: "sys_app",
+    sysId: scopeSysId,
+    label: "Application",
+    fields: {
+      name: scope.name,
+      scope: scope.prefix,
+      short_description: scope.name,
+      version: scope.version,
+      vendor: scope.vendor ?? "",
+      active: "true",
+      licensable: "false",
+      sys_class_name: "sys_app"
+    }
+  };
+}
+function escapeXML(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function wrapCDATA(str) {
+  return `<![CDATA[${str.replace(/]]>/g, "]]]]><![CDATA[>")}]]>`;
+}
+function buildFlatRecord(rec, packageRef, scopeRef) {
+  const skip = /* @__PURE__ */ new Set(["sys_id", "sys_scope", "sys_package", "sys_class_name", "sys_update_name"]);
+  const lines = [];
+  for (const [k, v] of Object.entries(rec.fields)) {
+    if (skip.has(k) || v === void 0 || v === null || Array.isArray(v) || typeof v === "object") continue;
+    const strVal = String(v);
+    const content = strVal.includes("<") || strVal.includes("&") || strVal.includes("\n") ? wrapCDATA(strVal) : escapeXML(strVal);
+    lines.push(`  <${k}>${content}</${k}>`);
+  }
+  lines.push(`  <sys_class_name>${rec.table}</sys_class_name>`);
+  lines.push(`  <sys_id>${rec.sysId}</sys_id>`);
+  lines.push(`  <sys_package>${packageRef}</sys_package>`);
+  lines.push(`  <sys_scope>${scopeRef}</sys_scope>`);
+  lines.push(`  <sys_update_name>${rec.table}_${rec.sysId}</sys_update_name>`);
+  return `<${rec.table} action="INSERT_OR_UPDATE">
+${lines.join("\n")}
+</${rec.table}>`;
+}
+function generateUpdateSetXML(build) {
+  const now = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").replace(/\.\d+Z$/, "");
+  const updateSetId = randomUUID().replace(/-/g, "");
+  const scopeSysId = build.scope ? randomUUID().replace(/-/g, "") : void 0;
+  const packageRef = scopeSysId ?? "global";
+  const scopeRef = scopeSysId ?? "global";
+  const appLabel = build.scope?.name ?? "Global";
+  const blocks = [];
+  blocks.push(
+    `<sys_update_set action="INSERT_OR_UPDATE">
+  <application display_value="${escapeXML(appLabel)}">${packageRef}</application>
+  <description>${escapeXML(build.description)}</description>
+  <is_default>false</is_default>
+  <name>${escapeXML(build.name)}</name>
+  <state>complete</state>
+  <sys_id>${updateSetId}</sys_id>
+</sys_update_set>`
+  );
+  if (build.scope && scopeSysId) {
+    blocks.push(buildFlatRecord(buildScopeRecord(build.scope, scopeSysId), packageRef, scopeRef));
+  }
+  for (const artifact of build.artifacts) {
+    for (const rec of expandArtifact(artifact, scopeSysId)) {
+      blocks.push(buildFlatRecord(rec, packageRef, scopeRef));
+    }
+  }
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<unload unload_date="${now}">
+${blocks.join("\n")}
+</unload>`;
+}
+function scopeFilter(scopeSysId) {
+  return `^sys_scope=${scopeSysId ?? "global"}`;
+}
+async function checkCrossScope(client, artifacts, targetScopeSysId, onWarning) {
+  const targetScope = targetScopeSysId ?? "global";
+  for (const artifact of artifacts) {
+    const table = ARTIFACT_TABLE[artifact.type];
+    if (!table) continue;
+    const name = String(artifact.fields["name"] ?? "");
+    if (!name) continue;
+    try {
+      const conflicts = await client.queryTable(table, {
+        sysparmQuery: `name=${name}^sys_scope!=${targetScope}`,
+        sysparmLimit: 1,
+        sysparmFields: "sys_id,sys_scope"
+      });
+      if (conflicts.length > 0) {
+        const conflictScope = String(conflicts[0]["sys_scope"] ?? "unknown");
+        onWarning(`  Warning: "${name}" (${artifact.type}) exists in scope "${conflictScope}" \u2014 your push targets "${targetScope}" so that record will not be touched`);
+      }
+    } catch {
+    }
+  }
+}
+async function resolveOrCreateScope(client, scope) {
+  const existing = await client.queryTable("sys_scope", {
+    sysparmQuery: `scope=${scope.prefix}`,
+    sysparmLimit: 1,
+    sysparmFields: "sys_id"
+  });
+  if (existing.length > 0) return String(existing[0].sys_id);
+  const created = await client.createRecord("sys_app", {
+    name: scope.name,
+    scope: scope.prefix,
+    short_description: scope.name,
+    version: scope.version,
+    vendor: scope.vendor ?? "",
+    active: true,
+    licensable: false,
+    sys_class_name: "sys_app"
+  });
+  return String(created.sys_id);
+}
+async function pushArtifacts(client, build, onProgress) {
+  const results = [];
+  const errors = [];
+  let scopeSysId;
+  if (build.scope) {
+    try {
+      onProgress?.(`  Resolving scope: ${build.scope.prefix}`);
+      scopeSysId = await resolveOrCreateScope(client, build.scope);
+      onProgress?.(`  Scope sys_id: ${scopeSysId}`);
+    } catch (err) {
+      errors.push({
+        type: "scope",
+        name: build.scope.prefix,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  await checkCrossScope(client, build.artifacts, scopeSysId, (msg) => onProgress?.(msg));
+  for (const artifact of build.artifacts) {
+    const artifactName = String(artifact.fields["name"] ?? artifact.type);
+    onProgress?.(`  Pushing ${artifact.type}: ${artifactName}`);
+    try {
+      if (artifact.type === "table") {
+        await pushTableArtifact(client, artifact, scopeSysId, results, errors, onProgress);
+      } else if (artifact.type === "decision_table") {
+        await pushDecisionTableArtifact(client, artifact, scopeSysId, results, errors, onProgress);
+      } else if (artifact.type === "flow_action") {
+        await pushFlowActionArtifact(client, artifact, scopeSysId, results, errors, onProgress);
+      } else {
+        const table = ARTIFACT_TABLE[artifact.type];
+        if (!table) {
+          errors.push({ type: artifact.type, name: artifactName, error: `Unknown artifact type: ${artifact.type}` });
+          continue;
+        }
+        const payload = { ...artifact.fields };
+        if (payload["active"] === void 0) payload["active"] = true;
+        if (scopeSysId) {
+          payload["sys_scope"] = scopeSysId;
+          payload["sys_package"] = scopeSysId;
+        }
+        const existing = await client.queryTable(table, {
+          sysparmQuery: `name=${artifactName}${scopeFilter(scopeSysId)}`,
+          sysparmLimit: 1,
+          sysparmFields: "sys_id"
+        });
+        if (existing.length > 0) {
+          const sysId = String(existing[0].sys_id);
+          await client.updateRecord(table, sysId, payload);
+          results.push({ type: artifact.type, name: artifactName, sysId, action: "updated" });
+        } else {
+          const created = await client.createRecord(table, payload);
+          results.push({ type: artifact.type, name: artifactName, sysId: String(created.sys_id), action: "created" });
+        }
+      }
+    } catch (err) {
+      errors.push({
+        type: artifact.type,
+        name: artifactName,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  return { results, errors };
+}
+async function pushTableArtifact(client, artifact, scopeSysId, results, errors, onProgress) {
+  const tableName = String(artifact.fields["name"] ?? "");
+  const dbObjPayload = {
+    name: tableName,
+    label: String(artifact.fields["label"] ?? tableName),
+    plural: String(artifact.fields["plural"] ?? String(artifact.fields["label"] ?? tableName) + "s"),
+    is_extendable: artifact.fields["is_extendable"] ? true : false
+  };
+  if (artifact.fields["extends"]) dbObjPayload["super_class"] = String(artifact.fields["extends"]);
+  if (scopeSysId) {
+    dbObjPayload["sys_scope"] = scopeSysId;
+    dbObjPayload["sys_package"] = scopeSysId;
+  }
+  const existingTable = await client.queryTable("sys_db_object", {
+    sysparmQuery: `name=${tableName}${scopeFilter(scopeSysId)}`,
+    sysparmLimit: 1,
+    sysparmFields: "sys_id"
+  });
+  let tableSysId;
+  if (existingTable.length > 0) {
+    tableSysId = String(existingTable[0].sys_id);
+    await client.updateRecord("sys_db_object", tableSysId, dbObjPayload);
+    results.push({ type: "Table", name: tableName, sysId: tableSysId, action: "updated" });
+  } else {
+    const created = await client.createRecord("sys_db_object", dbObjPayload);
+    tableSysId = String(created.sys_id);
+    results.push({ type: "Table", name: tableName, sysId: tableSysId, action: "created" });
+  }
+  const columns = Array.isArray(artifact.fields["columns"]) ? artifact.fields["columns"] : [];
+  for (const col of columns) {
+    const element = String(col["element"] ?? "");
+    const isChoice = String(col["internal_type"] ?? "") === "choice";
+    onProgress?.(`    column: ${tableName}.${element}`);
+    const dictPayload = {
+      name: tableName,
+      element,
+      column_label: String(col["label"] ?? element),
+      internal_type: isChoice ? "string" : String(col["internal_type"] ?? "string"),
+      max_length: col["max_length"] ?? (isChoice || String(col["internal_type"]) === "string" ? 255 : ""),
+      mandatory: col["mandatory"] ? true : false,
+      active: true
+    };
+    if (col["default_value"] !== void 0) dictPayload["default_value"] = String(col["default_value"]);
+    if (col["reference"]) dictPayload["reference"] = String(col["reference"]);
+    if (isChoice) dictPayload["choice"] = 1;
+    if (scopeSysId) {
+      dictPayload["sys_scope"] = scopeSysId;
+      dictPayload["sys_package"] = scopeSysId;
+    }
+    const existingDict = await client.queryTable("sys_dictionary", {
+      sysparmQuery: `name=${tableName}^element=${element}${scopeFilter(scopeSysId)}`,
+      sysparmLimit: 1,
+      sysparmFields: "sys_id"
+    });
+    if (existingDict.length > 0) {
+      await client.updateRecord("sys_dictionary", String(existingDict[0].sys_id), dictPayload);
+    } else {
+      await client.createRecord("sys_dictionary", dictPayload);
+    }
+    if (isChoice && Array.isArray(col["choices"])) {
+      const choices = col["choices"];
+      for (let ci = 0; ci < choices.length; ci++) {
+        const ch = choices[ci];
+        const choiceVal = typeof ch === "object" ? String(ch["value"] ?? "") : String(ch).toLowerCase().replace(/\s+/g, "_");
+        const choiceLabel = typeof ch === "object" ? String(ch["label"] ?? ch["value"] ?? "") : String(ch);
+        const choicePayload = {
+          name: tableName,
+          element,
+          value: choiceVal,
+          label: choiceLabel,
+          sequence: ci * 100,
+          inactive: false
+        };
+        if (scopeSysId) {
+          choicePayload["sys_scope"] = scopeSysId;
+          choicePayload["sys_package"] = scopeSysId;
+        }
+        const existingChoice = await client.queryTable("sys_choice", {
+          sysparmQuery: `name=${tableName}^element=${element}^value=${choiceVal}${scopeFilter(scopeSysId)}`,
+          sysparmLimit: 1,
+          sysparmFields: "sys_id"
+        });
+        if (existingChoice.length > 0) {
+          await client.updateRecord("sys_choice", String(existingChoice[0].sys_id), choicePayload);
+        } else {
+          await client.createRecord("sys_choice", choicePayload);
+        }
+      }
+    }
+  }
+}
+async function pushDecisionTableArtifact(client, artifact, scopeSysId, results, errors, onProgress) {
+  const dtName = String(artifact.fields["name"] ?? "");
+  const dtPayload = {
+    name: dtName,
+    label: String(artifact.fields["label"] ?? dtName),
+    description: String(artifact.fields["description"] ?? ""),
+    active: true
+  };
+  if (scopeSysId) {
+    dtPayload["sys_scope"] = scopeSysId;
+    dtPayload["sys_package"] = scopeSysId;
+  }
+  const existing = await client.queryTable("sys_decision", {
+    sysparmQuery: `name=${dtName}${scopeFilter(scopeSysId)}`,
+    sysparmLimit: 1,
+    sysparmFields: "sys_id"
+  });
+  let decisionSysId;
+  if (existing.length > 0) {
+    decisionSysId = String(existing[0].sys_id);
+    await client.updateRecord("sys_decision", decisionSysId, dtPayload);
+    results.push({ type: "Decision Table", name: dtName, sysId: decisionSysId, action: "updated" });
+    onProgress?.(`    Removing existing rules for: ${dtName}`);
+    for (const childTable of ["sys_decision_question", "sys_decision_case"]) {
+      const children = await client.queryTable(childTable, {
+        sysparmQuery: `decision=${decisionSysId}`,
+        sysparmFields: "sys_id",
+        sysparmLimit: 500
+      });
+      for (const child of children) {
+        await client.deleteRecord(childTable, String(child.sys_id));
+      }
+    }
+  } else {
+    const created = await client.createRecord("sys_decision", dtPayload);
+    decisionSysId = String(created.sys_id);
+    results.push({ type: "Decision Table", name: dtName, sysId: decisionSysId, action: "created" });
+  }
+  const inputs = Array.isArray(artifact.fields["inputs"]) ? artifact.fields["inputs"] : [];
+  const inputSysIds = {};
+  for (let i = 0; i < inputs.length; i++) {
+    const inp = inputs[i];
+    const inpName = String(inp["name"] ?? inp["field"] ?? `input_${i}`);
+    const qPayload = {
+      decision: decisionSysId,
+      label: String(inp["label"] ?? inpName),
+      order: i * 100,
+      question_type: String(inp["type"] ?? "string")
+    };
+    if (inp["reference"]) qPayload["reference_table"] = String(inp["reference"]);
+    if (scopeSysId) {
+      qPayload["sys_scope"] = scopeSysId;
+      qPayload["sys_package"] = scopeSysId;
+    }
+    const created = await client.createRecord("sys_decision_question", qPayload);
+    inputSysIds[inpName] = String(created.sys_id);
+  }
+  const rules = Array.isArray(artifact.fields["rules"]) ? artifact.fields["rules"] : [];
+  for (let ri = 0; ri < rules.length; ri++) {
+    const rule = rules[ri];
+    const casePayload = {
+      decision: decisionSysId,
+      label: String(rule["label"] ?? `Rule ${ri + 1}`),
+      order: ri * 100,
+      result: String(rule["result"] ?? "")
+    };
+    if (scopeSysId) {
+      casePayload["sys_scope"] = scopeSysId;
+      casePayload["sys_package"] = scopeSysId;
+    }
+    const createdCase = await client.createRecord("sys_decision_case", casePayload);
+    const caseSysId = String(createdCase.sys_id);
+    const conditions = Array.isArray(rule["conditions"]) ? rule["conditions"] : [];
+    for (const cond of conditions) {
+      const inputName = String(cond["input"] ?? "");
+      const cqPayload = {
+        case: caseSysId,
+        question: inputSysIds[inputName] ?? "",
+        operator: String(cond["operator"] ?? "="),
+        value: String(cond["value"] ?? "")
+      };
+      if (scopeSysId) {
+        cqPayload["sys_scope"] = scopeSysId;
+        cqPayload["sys_package"] = scopeSysId;
+      }
+      await client.createRecord("sys_decision_case_question", cqPayload);
+    }
+  }
+}
+async function pushFlowActionArtifact(client, artifact, scopeSysId, results, errors, onProgress) {
+  const actionName = String(artifact.fields["name"] ?? "");
+  const actionPayload = {
+    name: actionName,
+    label: String(artifact.fields["label"] ?? actionName),
+    description: String(artifact.fields["description"] ?? ""),
+    category: String(artifact.fields["category"] ?? "Custom"),
+    script: String(artifact.fields["script"] ?? ""),
+    active: true
+  };
+  if (scopeSysId) {
+    actionPayload["sys_scope"] = scopeSysId;
+    actionPayload["sys_package"] = scopeSysId;
+  }
+  const existing = await client.queryTable("sys_hub_action_type_definition", {
+    sysparmQuery: `name=${actionName}${scopeFilter(scopeSysId)}`,
+    sysparmLimit: 1,
+    sysparmFields: "sys_id"
+  });
+  let actionSysId;
+  if (existing.length > 0) {
+    actionSysId = String(existing[0].sys_id);
+    await client.updateRecord("sys_hub_action_type_definition", actionSysId, actionPayload);
+    results.push({ type: "Flow Action", name: actionName, sysId: actionSysId, action: "updated" });
+    onProgress?.(`    Removing existing variables for: ${actionName}`);
+    for (const childTable of ["sys_hub_action_input", "sys_hub_action_output"]) {
+      const children = await client.queryTable(childTable, {
+        sysparmQuery: `action_type=${actionSysId}`,
+        sysparmFields: "sys_id",
+        sysparmLimit: 100
+      });
+      for (const child of children) {
+        await client.deleteRecord(childTable, String(child.sys_id));
+      }
+    }
+  } else {
+    const created = await client.createRecord("sys_hub_action_type_definition", actionPayload);
+    actionSysId = String(created.sys_id);
+    results.push({ type: "Flow Action", name: actionName, sysId: actionSysId, action: "created" });
+  }
+  const inputs = Array.isArray(artifact.fields["inputs"]) ? artifact.fields["inputs"] : [];
+  for (let i = 0; i < inputs.length; i++) {
+    const inp = inputs[i];
+    const inpPayload = {
+      action_type: actionSysId,
+      name: String(inp["name"] ?? `input_${i}`),
+      label: String(inp["label"] ?? inp["name"] ?? `Input ${i + 1}`),
+      type: String(inp["type"] ?? "string"),
+      mandatory: inp["mandatory"] ? true : false,
+      order: i * 100
+    };
+    if (scopeSysId) {
+      inpPayload["sys_scope"] = scopeSysId;
+      inpPayload["sys_package"] = scopeSysId;
+    }
+    await client.createRecord("sys_hub_action_input", inpPayload);
+  }
+  const outputs = Array.isArray(artifact.fields["outputs"]) ? artifact.fields["outputs"] : [];
+  for (let i = 0; i < outputs.length; i++) {
+    const out = outputs[i];
+    const outPayload = {
+      action_type: actionSysId,
+      name: String(out["name"] ?? `output_${i}`),
+      label: String(out["label"] ?? out["name"] ?? `Output ${i + 1}`),
+      type: String(out["type"] ?? "string"),
+      order: i * 100
+    };
+    if (scopeSysId) {
+      outPayload["sys_scope"] = scopeSysId;
+      outPayload["sys_package"] = scopeSysId;
+    }
+    await client.createRecord("sys_hub_action_output", outPayload);
+  }
+}
+
+// src/commands/ai.ts
+var debugMode = false;
+function dbg(label, value) {
+  if (!debugMode) return;
+  console.error(chalk6.dim(`[debug] ${label}`));
+  if (typeof value === "string") {
+    console.error(chalk6.dim(value));
+  } else {
+    console.error(chalk6.dim(JSON.stringify(value, null, 2)));
+  }
+}
+function resolveProvider() {
+  const active = getActiveProvider();
+  if (!active) {
+    console.error(
+      chalk6.red("No LLM provider configured. Run `snow provider set <name>` first.")
+    );
+    process.exit(1);
+  }
+  dbg("active provider", { name: active.name, model: active.config.model });
+  return buildProvider(
+    active.name,
+    active.config.model,
+    active.config.apiKey,
+    active.config.baseUrl
+  );
+}
+function normaliseBuildResponse(parsed) {
+  const name = String(parsed["name"] ?? "");
+  const description = String(parsed["description"] ?? "");
+  if (!name) throw new Error('Response missing "name" field');
+  const rawArtifacts = parsed["artifacts"];
+  if (!Array.isArray(rawArtifacts)) {
+    throw new Error('Response missing "artifacts" array');
+  }
+  const artifacts = rawArtifacts.map((a, i) => {
+    if (typeof a !== "object" || a === null) {
+      throw new Error(`Artifact[${i}] is not an object`);
+    }
+    const art = a;
+    const type = String(art["type"] ?? "");
+    if (!type) throw new Error(`Artifact[${i}] missing "type"`);
+    let fields;
+    if (art["fields"] && typeof art["fields"] === "object" && !Array.isArray(art["fields"])) {
+      fields = art["fields"];
+    } else {
+      const { type: _t, ...rest } = art;
+      fields = rest;
+    }
+    return { type, fields };
+  });
+  let scope;
+  const rawScope = parsed["scope"];
+  if (rawScope && typeof rawScope === "object" && !Array.isArray(rawScope)) {
+    const s = rawScope;
+    const prefix = String(s["prefix"] ?? "");
+    if (prefix) {
+      scope = {
+        prefix,
+        name: String(s["name"] ?? prefix),
+        version: String(s["version"] ?? "1.0.0"),
+        ...s["vendor"] ? { vendor: String(s["vendor"]) } : {}
+      };
+    }
+  }
+  return { name, description, scope, artifacts };
+}
+function parseBuildResponse(raw) {
+  const json = extractJSON(raw);
+  dbg("extracted JSON", json);
+  const parsed = JSON.parse(json);
+  return normaliseBuildResponse(parsed);
+}
+function slugify(str) {
+  return str.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+function diffBuilds(previous, next) {
+  if (!previous) {
+    return { added: next.artifacts, updated: [], removed: [] };
+  }
+  const prevByKey = new Map(
+    previous.artifacts.map((a) => [`${a.type}:${String(a.fields["name"] ?? "")}`, a])
+  );
+  const nextByKey = new Map(
+    next.artifacts.map((a) => [`${a.type}:${String(a.fields["name"] ?? "")}`, a])
+  );
+  const added = [];
+  const updated = [];
+  const removed = [];
+  for (const [key, artifact] of nextByKey) {
+    if (!prevByKey.has(key)) {
+      added.push(artifact);
+    } else {
+      const prev = prevByKey.get(key);
+      if (JSON.stringify(prev.fields) !== JSON.stringify(artifact.fields)) {
+        updated.push(artifact);
+      }
+    }
+  }
+  for (const [key, artifact] of prevByKey) {
+    if (!nextByKey.has(key)) removed.push(artifact);
+  }
+  return { added, updated, removed };
+}
+function printBuildSummary(build, previous = null) {
+  console.log();
+  if (previous && previous.name !== build.name) {
+    console.log(`${chalk6.bold(build.name)} ${chalk6.dim(`(was: ${previous.name})`)}`);
+  } else {
+    console.log(chalk6.bold(build.name));
+  }
+  if (build.description) console.log(chalk6.dim(build.description));
+  if (build.scope) {
+    console.log(chalk6.dim(`  scope: ${chalk6.white(build.scope.prefix)}  v${build.scope.version}`));
+  }
+  console.log();
+  if (previous) {
+    const { added, updated, removed } = diffBuilds(previous, build);
+    if (added.length === 0 && updated.length === 0 && removed.length === 0) {
+      console.log(chalk6.dim("  No changes to artifacts."));
+    } else {
+      for (const a of added) {
+        console.log(`  ${chalk6.green("+")} ${chalk6.cyan(a.type.padEnd(16))} ${String(a.fields["name"] ?? "")}`);
+      }
+      for (const a of updated) {
+        console.log(`  ${chalk6.yellow("~")} ${chalk6.cyan(a.type.padEnd(16))} ${String(a.fields["name"] ?? "")}`);
+      }
+      for (const a of removed) {
+        console.log(`  ${chalk6.red("-")} ${chalk6.cyan(a.type.padEnd(16))} ${String(a.fields["name"] ?? "")}`);
+      }
+    }
+  } else {
+    for (const a of build.artifacts) {
+      const name = String(a.fields["name"] ?? "(unnamed)");
+      console.log(`  ${chalk6.green("+")} ${chalk6.cyan(a.type.padEnd(16))} ${name}`);
+    }
+  }
+  console.log();
+}
+function saveBuild(build, customDir) {
+  const dir = customDir ?? slugify(build.name);
+  mkdirSync3(dir, { recursive: true });
+  const base = slugify(build.name);
+  const xmlFile = join3(dir, `${base}.xml`);
+  const manifestFile = join3(dir, `${base}.manifest.json`);
+  writeFileSync3(xmlFile, generateUpdateSetXML(build), "utf-8");
+  writeFileSync3(manifestFile, JSON.stringify(build, null, 2), "utf-8");
+  return dir;
+}
+function printSaveResult(dir, build) {
+  const base = slugify(build.name);
+  console.log(chalk6.green(`\u2714 ${dir}/`));
+  console.log(chalk6.dim(`    ${base}.xml`));
+  console.log(chalk6.dim(`    ${base}.manifest.json`));
+  console.log(chalk6.dim("  Import: System Update Sets \u2192 Retrieved Update Sets \u2192 Import XML"));
+}
+async function doPush(build) {
+  const instance = getActiveInstance();
+  if (!instance) {
+    console.error(chalk6.red("No active instance. Run `snow instance add` first."));
+    process.exit(1);
+  }
+  const { ServiceNowClient: ServiceNowClient2 } = await Promise.resolve().then(() => (init_client(), client_exports));
+  const client = new ServiceNowClient2(instance);
+  console.log(chalk6.bold(`Pushing to ${instance.alias} (${instance.url})\u2026`));
+  const summary = await pushArtifacts(
+    client,
+    build,
+    (msg) => console.log(chalk6.dim(msg))
+  );
+  console.log();
+  for (const r of summary.results) {
+    const action = r.action === "created" ? chalk6.green("created") : chalk6.yellow("updated");
+    console.log(`  ${action}  ${r.type.padEnd(16)} ${r.name}  ${chalk6.dim(r.sysId)}`);
+  }
+  for (const e of summary.errors) {
+    console.log(`  ${chalk6.red("error")}   ${e.type.padEnd(16)} ${e.name}  ${chalk6.red(e.error)}`);
+  }
+  console.log(chalk6.dim(`
+${summary.results.length} pushed, ${summary.errors.length} failed`));
+}
+async function confirmPush(build, dir, autoPush) {
+  const instance = getActiveInstance();
+  if (!instance) {
+    console.log(chalk6.dim(`  Run \`snow ai push ${dir}/\` to deploy later.`));
+    return;
+  }
+  let shouldPush = autoPush ?? false;
+  if (!shouldPush) {
+    console.log();
+    const { confirm: confirm2 } = await import("@inquirer/prompts");
+    shouldPush = await confirm2({
+      message: `Push ${build.artifacts.length} artifact(s) to ${chalk6.cyan(instance.alias)} (${instance.url})?`,
+      default: false
+    });
+  }
+  if (shouldPush) {
+    console.log();
+    await doPush(build);
+  } else {
+    console.log(chalk6.dim(`  Run \`snow ai push ${dir}/\` to deploy later.`));
+  }
+}
+var CODE_FIELDS = {
+  script_include: [{ field: "script", ext: ".js", label: "Script" }],
+  business_rule: [{ field: "script", ext: ".js", label: "Script" }],
+  client_script: [{ field: "script", ext: ".js", label: "Script" }],
+  ui_action: [
+    { field: "script", ext: ".js", label: "Server Script" },
+    { field: "onclick", ext: ".js", label: "Client onclick" }
+  ],
+  ui_page: [
+    { field: "html", ext: ".html", label: "HTML" },
+    { field: "client_script", ext: ".js", label: "Client Script" },
+    { field: "processing_script", ext: ".js", label: "Processing Script" }
+  ],
+  scheduled_job: [{ field: "script", ext: ".js", label: "Script" }],
+  flow_action: [{ field: "script", ext: ".js", label: "Action Script" }]
+  // table and decision_table have no inline code fields — schema is reviewed via the manifest
+};
+function resolveEditor2() {
+  if (process.env["VISUAL"]) return process.env["VISUAL"];
+  if (process.env["EDITOR"]) return process.env["EDITOR"];
+  const isWin = process.platform === "win32";
+  const lookup = isWin ? "where" : "which";
+  const candidates = isWin ? ["code", "notepad++", "notepad"] : ["code", "nvim", "vim", "nano", "vi"];
+  for (const e of candidates) {
+    if (spawnSync2(lookup, [e], { encoding: "utf-8", shell: isWin }).status === 0) return e;
+  }
+  return isWin ? "notepad" : "vi";
+}
+function resolveManifestPath(path2) {
+  if (path2.endsWith(".manifest.json") && existsSync3(path2)) return path2;
+  if (path2.endsWith(".xml")) {
+    const m = path2.replace(/\.xml$/, ".manifest.json");
+    if (existsSync3(m)) return m;
+  }
+  if (existsSync3(path2) && !path2.includes(".")) {
+    const files = readdirSync2(path2).filter((f) => f.endsWith(".manifest.json"));
+    if (files.length > 0) return join3(path2, files[0]);
+  }
+  console.error(chalk6.red(`Cannot resolve build manifest from: ${path2}`));
+  console.error(chalk6.dim("Pass a build directory, a .xml file, or a .manifest.json file."));
+  process.exit(1);
+}
+function printCodeBlock(code, label) {
+  const lines = code.split("\n");
+  const width = Math.min(process.stdout.columns ?? 100, 100);
+  console.log(chalk6.dim("\u2500".repeat(width) + ` ${label}`));
+  lines.forEach((line, i) => {
+    const num = chalk6.dim(String(i + 1).padStart(4) + "  ");
+    console.log(num + line);
+  });
+  console.log(chalk6.dim("\u2500".repeat(width)));
+}
+async function runReview(build, buildDir) {
+  const { select: select2, confirm: confirm2 } = await import("@inquirer/prompts");
+  const editor = resolveEditor2();
+  let modified = false;
+  console.log();
+  console.log(chalk6.bold(`Reviewing: ${build.name}`));
+  console.log(chalk6.dim(`${build.artifacts.length} artifact(s)  \u2022  editor: ${editor}`));
+  console.log();
+  while (true) {
+    const artifactChoices = build.artifacts.map((a, i) => {
+      const name = String(a.fields["name"] ?? `(${a.type})`);
+      const hasCode = (CODE_FIELDS[a.type] ?? []).some((f) => {
+        const v = a.fields[f.field];
+        return v !== void 0 && v !== null && String(v).trim() !== "";
+      });
+      return {
+        name: `${chalk6.cyan(a.type.padEnd(16))} ${name}${hasCode ? "" : chalk6.dim(" (no code)")}`,
+        value: i
+      };
+    });
+    artifactChoices.push({ name: chalk6.dim("\u2500\u2500 Done reviewing \u2500\u2500"), value: -1 });
+    const selectedIndex = await select2({
+      message: "Select an artifact to review:",
+      choices: artifactChoices
+    });
+    if (selectedIndex === -1) break;
+    const artifact = build.artifacts[selectedIndex];
+    const artifactName = String(artifact.fields["name"] ?? artifact.type);
+    const codeFields = (CODE_FIELDS[artifact.type] ?? []).filter(
+      (f) => artifact.fields[f.field] !== void 0
+    );
+    if (codeFields.length === 0) {
+      console.log(chalk6.yellow("  No editable code fields for this artifact type."));
+      continue;
+    }
+    let fieldDef = codeFields[0];
+    if (codeFields.length > 1) {
+      const fieldIndex = await select2({
+        message: `Which field of "${artifactName}" to review?`,
+        choices: codeFields.map((f, i) => ({ name: f.label, value: i }))
+      });
+      fieldDef = codeFields[fieldIndex];
+    }
+    const currentCode = String(artifact.fields[fieldDef.field] ?? "");
+    console.log();
+    printCodeBlock(currentCode, `${artifactName} \u2014 ${fieldDef.label}`);
+    console.log();
+    const shouldEdit = await confirm2({ message: "Open in editor to edit?", default: false });
+    if (shouldEdit) {
+      const tmpFile = join3(tmpdir2(), `snow-review-${Date.now()}${fieldDef.ext}`);
+      writeFileSync3(tmpFile, currentCode, "utf-8");
+      const isWin = process.platform === "win32";
+      spawnSync2(editor, [tmpFile], { stdio: "inherit", shell: isWin });
+      const updatedCode = readFileSync3(tmpFile, "utf-8");
+      if (updatedCode !== currentCode) {
+        build.artifacts[selectedIndex].fields[fieldDef.field] = updatedCode;
+        modified = true;
+        const base = slugify(build.name);
+        const xmlFile = join3(buildDir, `${base}.xml`);
+        const manifestFile = join3(buildDir, `${base}.manifest.json`);
+        writeFileSync3(xmlFile, generateUpdateSetXML(build), "utf-8");
+        writeFileSync3(manifestFile, JSON.stringify(build, null, 2), "utf-8");
+        console.log(chalk6.green(`  \u2714 Saved changes to ${basename(manifestFile)}`));
+      } else {
+        console.log(chalk6.dim("  No changes made."));
+      }
+    }
+    console.log();
+  }
+  if (modified) {
+    console.log(chalk6.green("\u2714 Build updated with your edits."));
+  }
+  return build;
+}
+function aiCommand() {
+  const cmd = new Command6("ai").description(
+    "Generate ServiceNow applications using an LLM and export as an update set"
+  );
+  cmd.command("build <prompt>").description("Generate a ServiceNow application from a text description").option("-o, --output <dir>", "Output directory (default: slugified update set name)").option("--push", "Push artifacts directly to the active instance after generating").option("--provider <name>", "Override the active provider for this request").option("--debug", "Print raw LLM request/response and full error stack traces").action(
+    async (prompt, opts) => {
+      if (opts.debug) debugMode = true;
+      let provider = resolveProvider();
+      if (opts.provider) {
+        const { getAIConfig: getAIConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+        const ai = getAIConfig2();
+        const pc = ai.providers[opts.provider];
+        if (!pc) {
+          console.error(chalk6.red(`Provider "${opts.provider}" is not configured.`));
+          process.exit(1);
+        }
+        provider = buildProvider(opts.provider, pc.model, pc.apiKey, pc.baseUrl);
+      }
+      dbg("prompt", prompt);
+      const history = [
+        { role: "system", content: SN_SYSTEM_PROMPT },
+        { role: "user", content: prompt }
+      ];
+      const { input: promptInput } = await import("@inquirer/prompts");
+      let build = null;
+      while (!build) {
+        const spinner = ora5(`Generating with ${provider.providerName}\u2026`).start();
+        let raw;
+        try {
+          raw = await provider.complete(history);
+          spinner.stop();
+          dbg("raw LLM response", raw);
+        } catch (err) {
+          spinner.fail(chalk6.red("LLM request failed"));
+          console.error(chalk6.red(opts.debug && err instanceof Error ? err.stack ?? err.message : err instanceof Error ? err.message : String(err)));
+          process.exit(1);
+        }
+        history.push({ role: "assistant", content: raw });
+        let parsed = null;
+        try {
+          parsed = parseBuildResponse(raw);
+          dbg("parsed build", parsed);
+        } catch {
+        }
+        if (parsed) {
+          build = parsed;
+        } else {
+          console.log();
+          const lines = raw.trim().split("\n");
+          console.log(chalk6.magenta("AI > ") + lines[0]);
+          for (let i = 1; i < lines.length; i++) {
+            console.log("     " + lines[i]);
+          }
+          console.log();
+          let answer = "";
+          while (!answer.trim()) {
+            answer = await promptInput({ message: chalk6.cyan("You") });
+          }
+          history.push({ role: "user", content: answer.trim() });
+        }
+      }
+      const validationErrors = validateBuild(build);
+      if (validationErrors.length > 0) {
+        console.warn(chalk6.yellow("Warning: some artifacts are missing required fields:"));
+        for (const e of validationErrors) {
+          console.warn(chalk6.yellow(`  [${e.artifactIndex}] ${e.type} "${e.name}" \u2014 missing: ${e.missing.join(", ")}`));
+        }
+        console.log();
+      }
+      printBuildSummary(build);
+      const dir = saveBuild(build, opts.output);
+      printSaveResult(dir, build);
+      const { confirm: confirmReview } = await import("@inquirer/prompts");
+      const wantReview = await confirmReview({
+        message: "Review generated artifacts before pushing?",
+        default: false
+      });
+      if (wantReview) {
+        build = await runReview(build, dir);
+      }
+      await confirmPush(build, dir, opts.push);
+    }
+  );
+  cmd.command("push <path>").description("Push a previously generated build to the active instance via Table API").action(async (path2) => {
+    let manifestPath;
+    if (path2.endsWith(".manifest.json") && existsSync3(path2)) {
+      manifestPath = path2;
+    } else if (path2.endsWith(".xml") && existsSync3(path2.replace(/\.xml$/, ".manifest.json"))) {
+      manifestPath = path2.replace(/\.xml$/, ".manifest.json");
+    } else if (!path2.includes(".") && existsSync3(path2)) {
+      const files = (await import("fs")).readdirSync(path2).filter((f) => f.endsWith(".manifest.json"));
+      if (files.length === 0) {
+        console.error(chalk6.red(`No .manifest.json found in directory: ${path2}`));
+        process.exit(1);
+      }
+      manifestPath = join3(path2, files[0]);
+    } else {
+      console.error(chalk6.red(`Cannot resolve build from: ${path2}`));
+      console.error(chalk6.dim("Pass a build directory, a .xml file, or a .manifest.json file."));
+      process.exit(1);
+    }
+    const build = JSON.parse(readFileSync3(manifestPath, "utf-8"));
+    await doPush(build);
+  });
+  cmd.command("chat").description("Interactively build a ServiceNow application through conversation with an LLM").option("-o, --output <dir>", "Directory to auto-save builds (default: slugified name)").option("--push", "Auto-push to the active instance when a build is generated").option("--debug", "Print raw LLM responses and full error stack traces").action(async (opts) => {
+    if (opts.debug) debugMode = true;
+    const provider = resolveProvider();
+    const history = [
+      { role: "system", content: SN_SYSTEM_PROMPT }
+    ];
+    const BANNER = `
+${chalk6.bold.cyan("Snow AI \u2014 ServiceNow App Builder")}
+${chalk6.dim(`Provider: ${chalk6.white(provider.providerName)}`)}
+${chalk6.dim("Describe what you want to build. The AI may ask clarifying questions before generating.")}
+${chalk6.dim("Slash commands:")}
+  ${chalk6.dim("/status    show current build")}
+  ${chalk6.dim("/save      write XML + manifest to disk")}
+  ${chalk6.dim("/push      push current build to active instance")}
+  ${chalk6.dim("/clear     reset the session")}
+  ${chalk6.dim("/exit      quit")}
+`;
+    console.log(BANNER);
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      prompt: chalk6.cyan("You > "),
+      terminal: true
+    });
+    let lastBuild = null;
+    let buildDir = null;
+    rl.prompt();
+    rl.on("line", async (line) => {
+      const input2 = line.trim();
+      if (!input2) {
+        rl.prompt();
+        return;
+      }
+      if (input2 === "/exit" || input2 === "/quit") {
+        console.log(chalk6.dim("Bye."));
+        rl.close();
+        return;
+      }
+      if (input2 === "/clear") {
+        history.splice(1);
+        lastBuild = null;
+        buildDir = null;
+        console.log(chalk6.dim("Session cleared."));
+        rl.prompt();
+        return;
+      }
+      if (input2 === "/status") {
+        if (!lastBuild) {
+          console.log(chalk6.dim("No build yet. Describe what you want to build."));
+        } else {
+          printBuildSummary(lastBuild);
+          if (buildDir) console.log(chalk6.dim(`Saved to: ${buildDir}/`));
+        }
+        rl.prompt();
+        return;
+      }
+      if (input2 === "/save") {
+        if (!lastBuild) {
+          console.log(chalk6.yellow("Nothing generated yet."));
+          rl.prompt();
+          return;
+        }
+        const dir = saveBuild(lastBuild, opts.output);
+        buildDir = dir;
+        printSaveResult(dir, lastBuild);
+        rl.prompt();
+        return;
+      }
+      if (input2 === "/push") {
+        if (!lastBuild) {
+          console.log(chalk6.yellow("Nothing generated yet."));
+          rl.prompt();
+          return;
+        }
+        rl.pause();
+        await doPush(lastBuild);
+        rl.resume();
+        rl.prompt();
+        return;
+      }
+      rl.pause();
+      history.push({ role: "user", content: input2 });
+      const spinner = ora5({ text: chalk6.dim("Thinking\u2026"), spinner: "dots", color: "cyan" }).start();
+      let raw;
+      try {
+        raw = await provider.complete(history);
+        spinner.stop();
+        dbg("raw LLM response", raw);
+      } catch (err) {
+        spinner.stop();
+        console.error(chalk6.red(opts.debug && err instanceof Error ? err.stack ?? err.message : `Error: ${err instanceof Error ? err.message : String(err)}`));
+        history.pop();
+        rl.resume();
+        rl.prompt();
+        return;
+      }
+      history.push({ role: "assistant", content: raw });
+      let parsedBuild = null;
+      try {
+        parsedBuild = parseBuildResponse(raw);
+        dbg("parsed build", parsedBuild);
+      } catch (err) {
+        if (opts.debug) {
+          console.error(chalk6.dim(`[debug] not a build response: ${err instanceof Error ? err.message : String(err)}`));
+        }
+      }
+      if (parsedBuild) {
+        const previous = lastBuild;
+        lastBuild = parsedBuild;
+        printBuildSummary(parsedBuild, previous);
+        const validationErrors = validateBuild(parsedBuild);
+        if (validationErrors.length > 0) {
+          console.warn(chalk6.yellow("Warning: some artifacts are missing required fields:"));
+          for (const e of validationErrors) {
+            console.warn(chalk6.yellow(`  [${e.artifactIndex}] ${e.type} "${e.name}" \u2014 missing: ${e.missing.join(", ")}`));
+          }
+          console.log();
+        }
+        const dir = saveBuild(parsedBuild, opts.output ?? buildDir ?? void 0);
+        buildDir = dir;
+        printSaveResult(dir, parsedBuild);
+        await confirmPush(parsedBuild, dir, opts.push);
+        console.log(chalk6.dim(`  /push to redeploy  |  /save to re-save  |  /status for summary`));
+        console.log();
+      } else {
+        console.log();
+        const lines = raw.trim().split("\n");
+        const prefix = chalk6.magenta("AI > ");
+        console.log(prefix + lines[0]);
+        for (let i = 1; i < lines.length; i++) {
+          console.log("     " + lines[i]);
+        }
+        console.log();
+      }
+      rl.resume();
+      rl.prompt();
+    });
+    rl.on("close", () => process.exit(0));
+    process.on("SIGINT", () => {
+      console.log(chalk6.dim("\nBye."));
+      process.exit(0);
+    });
+  });
+  cmd.command("review <path>").description("Review and edit generated artifacts, then optionally push to the active instance").action(async (path2) => {
+    const manifestPath = resolveManifestPath(path2);
+    const buildDir = dirname(manifestPath);
+    let build = JSON.parse(readFileSync3(manifestPath, "utf-8"));
+    build = await runReview(build, buildDir);
+    console.log();
+    await confirmPush(build, buildDir);
+  });
+  cmd.command("save-manifest <jsonFile>").description("Convert a raw LLM JSON response into a build directory").option("-o, --output <dir>", "Output directory").action(async (jsonFile, opts) => {
+    if (!existsSync3(jsonFile)) {
+      console.error(chalk6.red(`File not found: ${jsonFile}`));
+      process.exit(1);
+    }
+    let build;
+    try {
+      build = parseBuildResponse(readFileSync3(jsonFile, "utf-8"));
+    } catch (err) {
+      console.error(chalk6.red(`Failed to parse: ${err instanceof Error ? err.message : String(err)}`));
+      process.exit(1);
+    }
+    printBuildSummary(build);
+    const dir = saveBuild(build, opts.output);
+    printSaveResult(dir, build);
+  });
+  return cmd;
+}
+
+// src/index.ts
+import { readFileSync as readFileSync4 } from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { join as join4, dirname as dirname2 } from "path";
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = dirname2(__filename2);
+function getVersion() {
+  try {
+    const pkg = JSON.parse(
+      readFileSync4(join4(__dirname2, "..", "package.json"), "utf-8")
+    );
+    return pkg.version;
+  } catch {
+    return "0.0.0";
+  }
+}
+var program = new Command7();
+program.name("snow").description(chalk7.bold("snow") + " \u2014 ServiceNow CLI: query tables, edit scripts, and generate apps with AI").version(getVersion(), "-v, --version", "Output the current version").addHelpText(
+  "after",
+  `
+${chalk7.bold("Examples:")}
+  ${chalk7.dim("# Add a ServiceNow instance")}
+  snow instance add
+
+  ${chalk7.dim("# Query records from a table")}
+  snow table get incident -q "active=true" -l 10
+
+  ${chalk7.dim("# View the schema for a table")}
+  snow schema incident
+
+  ${chalk7.dim("# Pull a script field, edit it, and push back")}
+  snow script pull sys_script_include <sys_id> script
+
+  ${chalk7.dim("# Configure an LLM provider (OpenAI, Anthropic, xAI/Grok, or Ollama)")}
+  snow provider set openai
+  snow provider set anthropic
+  snow provider set xai
+  snow provider set ollama --model llama3
+
+  ${chalk7.dim("# Generate a ServiceNow app and export as an update set XML")}
+  snow ai build "Create a script include that auto-routes incidents by category"
+
+  ${chalk7.dim("# Generate and immediately push artifacts to the active instance")}
+  snow ai build "Create a business rule that sets priority on incident insert" --push
+
+  ${chalk7.dim("# Interactive multi-turn app builder")}
+  snow ai chat
+`
+);
+program.addCommand(instanceCommand());
+program.addCommand(tableCommand());
+program.addCommand(schemaCommand());
+program.addCommand(scriptCommand());
+program.addCommand(providerCommand());
+program.addCommand(aiCommand());
+program.command("instances", { hidden: true }).description("Alias for `snow instance list`").action(() => {
+  const sub = instanceCommand();
+  sub.parse(["node", "snow", "list"]);
+});
+program.parseAsync(process.argv).catch((err) => {
+  console.error(chalk7.red(err instanceof Error ? err.message : String(err)));
+  process.exit(1);
+});