@superatomai/sdk-node 0.0.44 → 0.0.45-dsp

package/dist/userResponse/scripts/script-bootstrap.mjs

@@ -0,0 +1,530 @@
+// src/userResponse/scripts/script-bootstrap.ts
+import { pathToFileURL } from "url";
+
+// src/userResponse/scripts/script-ipc.ts
+function encodeMessage(msg) {
+  return JSON.stringify(msg) + "\n";
+}
+var LineOverflowError = class extends Error {
+  constructor(buffered, limit) {
+    super(`IPC message exceeded ${limit} bytes without a newline (${buffered} buffered) \u2014 aborting to avoid unbounded memory.`);
+    this.buffered = buffered;
+    this.limit = limit;
+    this.name = "LineOverflowError";
+  }
+};
+var DEFAULT_MAX_IPC_BYTES = (() => {
+  const envVal = Number(process.env.SCRIPT_MAX_IPC_BYTES);
+  return Number.isFinite(envVal) && envVal > 0 ? Math.floor(envVal) : 64 * 1024 * 1024;
+})();
+var LineSplitter = class {
+  constructor(maxBytes = DEFAULT_MAX_IPC_BYTES) {
+    this.maxBytes = maxBytes;
+    this.buffer = "";
+  }
+  push(chunk) {
+    this.buffer += chunk;
+    const lines = [];
+    let idx;
+    while ((idx = this.buffer.indexOf("\n")) !== -1) {
+      const line = this.buffer.slice(0, idx);
+      this.buffer = this.buffer.slice(idx + 1);
+      if (line.length > 0) lines.push(line);
+    }
+    if (this.buffer.length > this.maxBytes) {
+      const buffered = this.buffer.length;
+      this.buffer = "";
+      throw new LineOverflowError(buffered, this.maxBytes);
+    }
+    return lines;
+  }
+  /** Flush any remaining partial data (useful on stream close) */
+  flush() {
+    if (this.buffer.length === 0) return null;
+    const rest = this.buffer;
+    this.buffer = "";
+    return rest;
+  }
+};
+
+// src/userResponse/scripts/fmt.ts
+var DASH = "\u2014";
+var DEFAULT_FMT_CONFIG = { locale: "en-IN", currency: "INR" };
+var MONEY_TIERS = {
+  "en-IN": [[1e7, "Cr"], [1e5, "L"]],
+  "hi-IN": [[1e7, "Cr"], [1e5, "L"]]
+};
+var DEFAULT_MONEY_TIERS = [[1e9, "B"], [1e6, "M"]];
+function moneyTiers(locale) {
+  return MONEY_TIERS[locale] ?? DEFAULT_MONEY_TIERS;
+}
+var COUNT_SCALE_MIN = 1e7;
+function toNum(v) {
+  if (v === null || v === void 0 || v === "") return null;
+  const n = typeof v === "number" ? v : Number(v);
+  return Number.isFinite(n) ? n : null;
+}
+var MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+var ISO_DATE = /^\d{4}-\d{2}-\d{2}([T ]|$)/;
+function toDate(v) {
+  if (v === null || v === void 0 || v === "") return null;
+  if (v instanceof Date) return Number.isNaN(v.getTime()) ? null : v;
+  if (typeof v === "number") {
+    const d = new Date(v);
+    return Number.isNaN(d.getTime()) ? null : d;
+  }
+  if (typeof v === "string" && ISO_DATE.test(v.trim())) {
+    const d = new Date(v.trim());
+    return Number.isNaN(d.getTime()) ? null : d;
+  }
+  return null;
+}
+function makeFmt(cfg = {}) {
+  const locale = cfg.locale || DEFAULT_FMT_CONFIG.locale;
+  const currency = cfg.currency || DEFAULT_FMT_CONFIG.currency;
+  const group = (n, decimals = 0) => n.toLocaleString(locale, { minimumFractionDigits: decimals, maximumFractionDigits: decimals });
+  const symbol = (() => {
+    try {
+      const parts = new Intl.NumberFormat(locale, { style: "currency", currency }).formatToParts(0);
+      return parts.find((p) => p.type === "currency")?.value ?? "";
+    } catch {
+      return "";
+    }
+  })();
+  const scaled = (abs, tiers, decimals) => {
+    for (const [threshold, unit] of tiers) {
+      if (abs >= threshold) return `${group(abs / threshold, decimals)} ${unit}`;
+    }
+    return null;
+  };
+  function money(v, decimals = 2) {
+    const n = toNum(v);
+    if (n === null) return DASH;
+    const sign = n < 0 ? "-" : "";
+    const abs = Math.abs(n);
+    const tiers = moneyTiers(locale);
+    for (let i = 0; i < tiers.length; i++) {
+      const [threshold, unit] = tiers[i];
+      if (abs < threshold) continue;
+      const value = Number((abs / threshold).toFixed(decimals));
+      const higher = tiers[i - 1];
+      if (higher && value * threshold >= higher[0]) {
+        return `${sign}${symbol}${group(abs / higher[0], decimals)} ${higher[1]}`;
+      }
+      return `${sign}${symbol}${group(abs / threshold, decimals)} ${unit}`;
+    }
+    try {
+      return new Intl.NumberFormat(locale, {
+        style: "currency",
+        currency,
+        minimumFractionDigits: Number.isInteger(n) ? 0 : decimals,
+        maximumFractionDigits: decimals
+      }).format(n);
+    } catch {
+      return `${sign}${symbol}${group(abs, Number.isInteger(abs) ? 0 : decimals)}`;
+    }
+  }
+  function num(v, decimals) {
+    const n = toNum(v);
+    if (n === null) return DASH;
+    return group(n, decimals ?? (Number.isInteger(n) ? 0 : 2));
+  }
+  function count(v, decimals = 2) {
+    const n = toNum(v);
+    if (n === null) return DASH;
+    const abs = Math.abs(n);
+    const s = abs >= COUNT_SCALE_MIN ? scaled(abs, moneyTiers(locale), decimals) : null;
+    if (s) return `${n < 0 ? "-" : ""}${s}`;
+    return group(n, Number.isInteger(n) ? 0 : decimals);
+  }
+  function pct(part, whole, decimals = 1) {
+    const p = toNum(part), w = toNum(whole);
+    if (p === null || w === null || w === 0) return DASH;
+    return `${group(p / w * 100, decimals)}%`;
+  }
+  function delta(current, previous, decimals = 1) {
+    const c = toNum(current), p = toNum(previous);
+    if (c === null || p === null || p === 0) return DASH;
+    const change = (c - p) / Math.abs(p) * 100;
+    return `${change >= 0 ? "+" : "-"}${group(Math.abs(change), decimals)}%`;
+  }
+  function date(v) {
+    const d = toDate(v);
+    if (!d) return DASH;
+    return `${d.getUTCDate()} ${MONTHS[d.getUTCMonth()]} ${d.getUTCFullYear()}`;
+  }
+  function range(from, to) {
+    const a = toDate(from), b = toDate(to);
+    if (!a || !b) return DASH;
+    const left = a.getUTCFullYear() === b.getUTCFullYear() ? `${a.getUTCDate()} ${MONTHS[a.getUTCMonth()]}` : date(a);
+    return `${left} \u2013 ${date(b)}`;
+  }
+  function list(items, conjunction = "and") {
+    const parts = (items || []).map((i) => String(i ?? "").trim()).filter(Boolean);
+    if (!parts.length) return DASH;
+    if (parts.length === 1) return parts[0];
+    return `${parts.slice(0, -1).join(", ")} ${conjunction} ${parts[parts.length - 1]}`;
+  }
+  return { money, num, count, pct, delta, date, range, list };
+}
+
+// src/userResponse/scripts/script-bootstrap.ts
+var SCRIPT_ARG = process.argv[2];
+if (!SCRIPT_ARG) {
+  sendError("Bootstrap was invoked without a script path.", "compile");
+  process.exit(1);
+}
+var BRIDGE_URL = process.env.SCRIPT_BRIDGE_URL;
+var executedQueries = [];
+var PREVIEW_MAX_ROWS = 10;
+var PREVIEW_MAX_CHARS = 200;
+var QUERY_ROW_CAP = 250;
+function previewRows(data) {
+  return data.slice(0, PREVIEW_MAX_ROWS).map((row) => {
+    if (!row || typeof row !== "object") return row;
+    const out = {};
+    for (const [k, v] of Object.entries(row)) {
+      out[k] = typeof v === "string" && v.length > PREVIEW_MAX_CHARS ? v.slice(0, PREVIEW_MAX_CHARS) + "\u2026" : v;
+    }
+    return out;
+  });
+}
+var initResolve = null;
+var initPromise = new Promise((resolve) => {
+  initResolve = resolve;
+});
+function buildCtx(init) {
+  return {
+    now: init.now,
+    async query(toolId, sql) {
+      if (!BRIDGE_URL) throw new Error("SCRIPT_BRIDGE_URL is not set \u2014 script bridge server is not running");
+      const startedAt = Date.now();
+      send({ type: "stream", chunk: `
+\u{1F4DD} **Querying ${toolId}:**
+\`\`\`sql
+${sql}
+\`\`\`
+
+` });
+      send({ type: "stream", chunk: `__QUERY_TIMER_START_Executing query__` });
+      const res = await fetch(`${BRIDGE_URL}/query`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ toolId, sql, limit: QUERY_ROW_CAP })
+      });
+      const json = await res.json();
+      const executionTimeMs = Date.now() - startedAt;
+      send({ type: "stream", chunk: `__QUERY_TIMER_DONE_${(executionTimeMs / 1e3).toFixed(1)}__
+
+` });
+      if (!res.ok || !json.success) {
+        const errMsg = json.error || `Bridge query failed (${res.status})`;
+        send({ type: "stream", chunk: `\u274C **Query failed on ${toolId}:** ${errMsg}
+
+` });
+        throw new Error(errMsg);
+      }
+      if (json.metadata?.truncated) {
+        const total = json.metadata.totalCount ?? "more";
+        const hasGroupBy = /\bGROUP\s+BY\b/i.test(sql);
+        const explicitLimitMatch = sql.match(/\bLIMIT\s+(\d+)/i);
+        const hasDeliberateLimit = explicitLimitMatch != null && Number(explicitLimitMatch[1]) < QUERY_ROW_CAP;
+        if (hasGroupBy) {
+          send({ type: "stream", chunk: `\u2139\uFE0F Only the top ${QUERY_ROW_CAP} of ${total} grouped rows are returned (query is already aggregated via GROUP BY) \u2014 expected for a top-N request.
+
+` });
+        } else if (hasDeliberateLimit) {
+          send({ type: "stream", chunk: `\u2139\uFE0F Only the ${explicitLimitMatch[1]} rows requested (of ${total} matching) are returned \u2014 expected for a top-N request with an explicit LIMIT.
+
+` });
+        } else {
+          const msg = `ctx.query truncated the result of this query to ${QUERY_ROW_CAP} rows (it matched ${total}). Do NOT compute over raw rows \u2014 AGGREGATE IN SQL (GROUP BY / mode() / mode(...) FILTER (WHERE \u2026) / COUNT(...) FILTER (\u2026) / CASE) so the query returns the final, already-reduced rows, then have getData return those.`;
+          send({ type: "stream", chunk: `\u274C **Result truncated on ${toolId}:** ${msg}
+
+` });
+          throw new Error(msg);
+        }
+      }
+      const data = json.data ?? [];
+      const count = json.count ?? data.length;
+      send({ type: "stream", chunk: `\u2705 **${count} rows from ${toolId}**
+
+` });
+      if (data.length > 0) {
+        send({ type: "stream", chunk: `<DataTable>${JSON.stringify(previewRows(data))}</DataTable>
+
+` });
+      }
+      executedQueries.push({
+        sourceId: toolId,
+        sourceName: toolId,
+        // enriched by runner after result arrives
+        sql,
+        data,
+        count,
+        executionTimeMs
+      });
+      return { data, count };
+    },
+    /**
+     * Call a tool with structured params (typically a direct tool whose
+     * fn(params) does not expect a SQL string). Returns whatever the tool
+     * returned — shape is up to the tool.
+     *
+     * Use this when you need a pre-built business-logic tool (e.g.,
+     * "Calculate Shelf Life") that takes structured input rather than SQL.
+     * For SQL source tools, keep using ctx.query.
+     *
+     * runTool results do NOT auto-flow into executedQueries. If you want
+     * the result visualised, register it via ctx.emit() after extracting
+     * the array you want to chart.
+     */
+    async runTool(toolId, params = {}) {
+      if (!BRIDGE_URL) throw new Error("SCRIPT_BRIDGE_URL is not set \u2014 script bridge server is not running");
+      const res = await fetch(`${BRIDGE_URL}/run-tool`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ toolId, params })
+      });
+      const json = await res.json();
+      if (!res.ok || !json.success) throw new Error(json.error || `Bridge run-tool failed (${res.status})`);
+      return json.result;
+    },
+    /**
+     * Register a computed dataset. Flows into executedQueries alongside
+     * real SQL query results so component generation can render post-SQL
+     * transforms (weighted averages, clustering, joins) as charts.
+     */
+    emit(name, rows, meta) {
+      executedQueries.push({
+        sourceId: `computed:${name}`,
+        sourceName: meta?.description || name,
+        sql: `-- computed dataset: ${name}`,
+        data: Array.isArray(rows) ? rows : [],
+        count: Array.isArray(rows) ? rows.length : 0,
+        executionTimeMs: 0,
+        virtual: true
+      });
+    },
+    /**
+     * Forward a short progress message to the parent's StreamBuffer so the UI
+     * continues to see per-script feedback during execution.
+     */
+    log(chunk) {
+      send({ type: "stream", chunk });
+    }
+  };
+}
+function guardCtx(ctx) {
+  const PASSTHROUGH = /* @__PURE__ */ new Set([
+    "then",
+    "catch",
+    "finally",
+    "constructor",
+    "toJSON",
+    "inspect",
+    "valueOf",
+    "toString",
+    "hasOwnProperty",
+    "nodeType"
+  ]);
+  return new Proxy(ctx, {
+    get(target, prop, receiver) {
+      if (typeof prop === "symbol" || prop in target || PASSTHROUGH.has(prop)) {
+        return Reflect.get(target, prop, receiver);
+      }
+      const available = Reflect.ownKeys(target).filter((k) => typeof k === "string").join(", ");
+      throw new TypeError(
+        `ctx.${String(prop)} does not exist. ctx has exactly: ${available}. There are no formatting/parsing/date helpers on ctx \u2014 interpolate ISO date strings straight into the SQL and do date arithmetic in SQL.`
+      );
+    }
+  });
+}
+function send(msg) {
+  return process.stdout.write(encodeMessage(msg));
+}
+function sendError(message, phase, stack) {
+  send({ type: "error", message, stack, phase });
+}
+var splitter = new LineSplitter();
+process.stdin.setEncoding("utf-8");
+process.stdin.on("data", (chunk) => {
+  let lines;
+  try {
+    lines = splitter.push(chunk);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    sendError(msg, "runtime");
+    process.exit(1);
+  }
+  for (const line of lines) {
+    let msg;
+    try {
+      msg = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    handleMessage(msg);
+  }
+});
+function handleMessage(msg) {
+  switch (msg.type) {
+    case "init": {
+      if (initResolve) {
+        const now = new Date(msg.now || (/* @__PURE__ */ new Date()).toISOString());
+        const params = restoreParamTypes(msg.params || {}, msg.paramSchema);
+        initResolve({ params, now, mode: msg.mode, data: msg.data, datasets: msg.datasets, fmt: msg.fmt });
+        initResolve = null;
+      }
+      break;
+    }
+  }
+}
+function collectDatasets(queries) {
+  const out = {};
+  for (const q of queries) {
+    if (q.virtual && q.sourceId.startsWith("computed:")) {
+      out[q.sourceId.slice("computed:".length)] = q.data;
+    }
+  }
+  return out;
+}
+async function runComponents(mod, data, params, fmtCfg, datasets = {}) {
+  const getComponents = mod?.getComponents ?? mod?.default?.getComponents;
+  if (typeof getComponents !== "function") return {};
+  try {
+    const out = await getComponents(data, params, makeFmt(fmtCfg), datasets);
+    if (!Array.isArray(out)) {
+      return { componentsError: "getComponents must return an ARRAY of component specs" };
+    }
+    if (out.some((c) => !c || typeof c !== "object")) {
+      return { componentsError: "every entry getComponents returns must be a component spec object" };
+    }
+    return { components: out };
+  } catch (err) {
+    const e = err;
+    return { componentsError: e?.message || String(err) };
+  }
+}
+async function runAnalysis(mod, data, params, fmtCfg, datasets = {}) {
+  const getAnalysis = mod?.getAnalysis ?? mod?.default?.getAnalysis;
+  if (typeof getAnalysis !== "function") return {};
+  try {
+    const out = await getAnalysis(data, params, makeFmt(fmtCfg), datasets);
+    if (!out || typeof out !== "object") {
+      return { analysisError: "getAnalysis must return an object with { analysis, summary, method }" };
+    }
+    return {
+      analysis: {
+        analysis: typeof out.analysis === "string" ? out.analysis : void 0,
+        summary: Array.isArray(out.summary) ? out.summary.map((s) => String(s)) : void 0,
+        method: typeof out.method === "string" ? out.method : void 0
+      }
+    };
+  } catch (err) {
+    const e = err;
+    return { analysisError: e?.message || String(err) };
+  }
+}
+(async () => {
+  let mod;
+  let getData;
+  try {
+    mod = await import(pathToFileURL(SCRIPT_ARG).href);
+    getData = mod.getData ?? (typeof mod.default === "function" ? mod.default : mod.default?.getData);
+  } catch (err) {
+    const e = err;
+    sendError(e.message || String(err), "compile", e.stack);
+    process.exit(1);
+    return;
+  }
+  const init = await initPromise;
+  if (init.mode === "analysis" || init.mode === "components") {
+    const started = Date.now();
+    const rows = Array.isArray(init.data) ? init.data : [];
+    const ds = init.datasets ?? {};
+    const authored = init.mode === "analysis" ? await runAnalysis(mod, rows, init.params, init.fmt, ds) : await runComponents(mod, rows, init.params, init.fmt, ds);
+    const flushedAuthored = send({
+      type: "result",
+      data: [],
+      count: rows.length,
+      executedQueries: [],
+      executionTimeMs: Date.now() - started,
+      sampleRows: [],
+      ...authored
+    });
+    if (flushedAuthored) process.exit(0);
+    else process.stdout.once("drain", () => process.exit(0));
+    return;
+  }
+  if (typeof getData !== "function") {
+    sendError(
+      `Script at ${SCRIPT_ARG} does not export getData \u2014 expected \`export async function getData(ctx, params)\``,
+      "compile"
+    );
+    process.exit(1);
+    return;
+  }
+  const ctx = guardCtx(buildCtx(init));
+  const startedAt = Date.now();
+  try {
+    const raw = await getData(ctx, init.params);
+    const executionTimeMs = Date.now() - startedAt;
+    const data = normalizeResultData(raw);
+    const count = typeof raw?.count === "number" ? raw.count : data.length;
+    const sampleRows = data.slice(0, 5);
+    const ds = collectDatasets(executedQueries);
+    const { analysis, analysisError } = await runAnalysis(mod, data, init.params, init.fmt, ds);
+    const { components, componentsError } = await runComponents(mod, data, init.params, init.fmt, ds);
+    const result = {
+      type: "result",
+      data,
+      count,
+      executedQueries,
+      executionTimeMs,
+      sampleRows,
+      analysis,
+      analysisError,
+      components,
+      componentsError
+    };
+    const flushed = send(result);
+    if (flushed) {
+      process.exit(0);
+    } else {
+      process.stdout.once("drain", () => process.exit(0));
+    }
+  } catch (err) {
+    const e = err;
+    sendError(e.message || String(err), "runtime", e.stack);
+    process.exit(1);
+  }
+})();
+function normalizeResultData(raw) {
+  if (!raw) return [];
+  if (Array.isArray(raw)) return raw;
+  if (Array.isArray(raw.data)) return raw.data;
+  if (raw.data && typeof raw.data === "object") return [raw.data];
+  return [];
+}
+function restoreParamTypes(params, schema) {
+  if (!schema) return params;
+  const out = { ...params };
+  for (const [name, type] of Object.entries(schema)) {
+    const v = out[name];
+    if (v === void 0 || v === null) continue;
+    if (type === "date" && typeof v === "string") {
+      const d = new Date(v);
+      if (!isNaN(d.getTime())) out[name] = d;
+    } else if (type === "date_range" && typeof v === "object") {
+      const from = v.from;
+      const to = v.to;
+      out[name] = {
+        from: typeof from === "string" ? new Date(from) : from,
+        to: typeof to === "string" ? new Date(to) : to
+      };
+    }
+  }
+  return out;
+}
+//# sourceMappingURL=script-bootstrap.mjs.map

package/package.json

@@ -1,49 +1,52 @@
-{
-  "name": "@superatomai/sdk-node",
-  "version": "0.0.44",
-  "description": "Node.js TypeScript SDK for Superatom",
-  "main": "./dist/index.js",
-  "module": "./dist/index.mjs",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.mjs",
-      "require": "./dist/index.js"
-    }
-  },
-  "files": [
-    "dist"
-  ],
-  "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch",
-    "test": "tsx test-sdk.ts",
-    "prepublishOnly": "pnpm run build"
-  },
-  "keywords": [
-    "superatom",
-    "sdk",
-    "typescript"
-  ],
-  "author": "ashish@superatom.ai",
-  "license": "MIT",
-  "devDependencies": {
-    "@types/node": "^20.11.5",
-    "@types/ws": "^8.18.1",
-    "dotenv": "^17.2.3",
-    "tsup": "^8.0.1",
-    "tsx": "^4.20.6",
-    "typescript": "^5.3.3",
-    "ws": "^8.18.3"
-  },
-  "dependencies": {
-    "@anthropic-ai/sdk": "^0.66.0",
-    "@google/generative-ai": "^0.21.0",
-    "groq-sdk": "^0.33.0",
-    "jsonrepair": "^3.13.1",
-    "openai": "^4.77.0",
-    "ws": "^8.18.3",
-    "zod": "^3.25.76"
-  }
-}
+{
+  "name": "@superatomai/sdk-node",
+  "version": "0.0.45-dsp",
+  "description": "Node.js TypeScript SDK for Superatom",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.map"
+  ],
+  "keywords": [
+    "superatom",
+    "sdk",
+    "typescript"
+  ],
+  "author": "ashish@superatom.ai",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^20.11.5",
+    "@types/ws": "^8.18.1",
+    "dotenv": "^17.2.3",
+    "tsup": "^8.0.1",
+    "tsx": "^4.20.6",
+    "typescript": "^5.3.3",
+    "ws": "^8.21.0"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.66.0",
+    "@earendil-works/pi-coding-agent": "^0.80.3",
+    "@google/generative-ai": "^0.21.0",
+    "groq-sdk": "^0.33.0",
+    "jsonrepair": "^3.13.1",
+    "openai": "^4.77.0",
+    "typebox": "^1.1.38",
+    "ws": "^8.21.0",
+    "zod": "^3.25.76"
+  },
+  "scripts": {
+    "build": "tsc --noEmit && tsup",
+    "dev": "tsup --watch",
+    "test": "tsx test-sdk.ts",
+    "type-check": "tsc --noEmit"
+  }
+}