@bonnard/mcp-charts 0.1.1

package/dist/postgres.d.ts

@@ -0,0 +1,23 @@
+import { Pool } from 'pg';
+import { C as ChartData } from './types-CHiUU9mj.js';
+
+/** A Postgres result column: name + the type OID (`dataTypeID` from pg/PGlite result `fields`). */
+interface PostgresField {
+    name: string;
+    dataTypeID: number;
+}
+/**
+ * Convert a Postgres result into ChartData.
+ * @param rows   Result rows (objects), as returned by node-postgres or PGlite (`result.rows`).
+ * @param fields Result columns (`result.fields`: name + dataTypeID).
+ */
+declare function postgresToChartData(rows: Record<string, unknown>[], fields: PostgresField[]): ChartData;
+
+interface PostgresRunSqlOptions {
+    /** Reject non-SELECT statements + run inside a READ ONLY transaction. Default: true. */
+    readOnly?: boolean;
+}
+/** Build the `runSql` callback for `addCharts` from a pg Pool. */
+declare function postgresRunSql(pool: Pool, opts?: PostgresRunSqlOptions): (sql: string) => Promise<ChartData>;
+
+export { type PostgresField, type PostgresRunSqlOptions, postgresRunSql, postgresToChartData };

package/dist/postgres.js

@@ -0,0 +1,70 @@
+import {
+  assertReadOnlySql,
+  buildChartData,
+  defaultNormalizeCell
+} from "./chunk-NGXV4I2L.js";
+
+// src/adapters/postgres.ts
+var OID = {
+  BOOL: 16,
+  INT8: 20,
+  INT2: 21,
+  INT4: 23,
+  OID: 26,
+  FLOAT4: 700,
+  FLOAT8: 701,
+  NUMERIC: 1700,
+  DATE: 1082,
+  TIMESTAMP: 1114,
+  TIMESTAMPTZ: 1184
+};
+var NUMERIC = /* @__PURE__ */ new Set([OID.INT8, OID.INT2, OID.INT4, OID.OID, OID.FLOAT4, OID.FLOAT8, OID.NUMERIC]);
+var TEMPORAL = /* @__PURE__ */ new Set([OID.DATE, OID.TIMESTAMP, OID.TIMESTAMPTZ]);
+function pgKind(oid) {
+  if (NUMERIC.has(oid)) return "number";
+  if (TEMPORAL.has(oid)) return "time";
+  if (oid === OID.BOOL) return "boolean";
+  return "string";
+}
+function pgNormalize(value, kind, column) {
+  if (kind === "time" && value instanceof Date) {
+    if (column.type === OID.DATE) {
+      const y = value.getFullYear();
+      const m = String(value.getMonth() + 1).padStart(2, "0");
+      const d = String(value.getDate()).padStart(2, "0");
+      return `${y}-${m}-${d}`;
+    }
+    return value.toISOString();
+  }
+  return defaultNormalizeCell(value, kind);
+}
+function postgresToChartData(rows, fields) {
+  const columns = fields.map((f) => ({ name: f.name, type: f.dataTypeID }));
+  return buildChartData({ rows, columns, mapKind: (oid) => pgKind(oid), normalizeCell: pgNormalize });
+}
+
+// src/postgres.ts
+function postgresRunSql(pool, opts = {}) {
+  const readOnly = opts.readOnly !== false;
+  return async (sql) => {
+    if (readOnly) assertReadOnlySql(sql);
+    const client = await pool.connect();
+    try {
+      if (readOnly) await client.query("BEGIN TRANSACTION READ ONLY");
+      const res = await client.query(sql);
+      if (readOnly) await client.query("ROLLBACK");
+      return postgresToChartData(res.rows, res.fields);
+    } catch (err) {
+      if (readOnly) await client.query("ROLLBACK").catch(() => {
+      });
+      throw err;
+    } finally {
+      client.release();
+    }
+  };
+}
+export {
+  postgresRunSql,
+  postgresToChartData
+};
+//# sourceMappingURL=postgres.js.map

package/dist/postgres.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/adapters/postgres.ts","../src/postgres.ts"],"sourcesContent":["// Postgres -> ChartData adapter. Engine-specific pieces only: the OID -> FieldKind map and a\n// date-safe cell normalizer. Works for any driver whose result exposes { name, dataTypeID } columns\n// (node-postgres and PGlite both do). FieldMeta assembly + ChartData shape come from ./sql.\nimport type { ChartData, FieldKind } from \"../types.js\";\nimport { buildChartData, defaultNormalizeCell, type SourceColumn } from \"./sql.js\";\n\n// Postgres builtin type OIDs. These are fixed system-catalog identifiers (part of the wire\n// protocol), stable across versions — the same constants pg-types ships as `builtins`.\nconst OID = {\n  BOOL: 16,\n  INT8: 20,\n  INT2: 21,\n  INT4: 23,\n  OID: 26,\n  FLOAT4: 700,\n  FLOAT8: 701,\n  NUMERIC: 1700,\n  DATE: 1082,\n  TIMESTAMP: 1114,\n  TIMESTAMPTZ: 1184,\n} as const;\n\nconst NUMERIC = new Set<number>([OID.INT8, OID.INT2, OID.INT4, OID.OID, OID.FLOAT4, OID.FLOAT8, OID.NUMERIC]);\nconst TEMPORAL = new Set<number>([OID.DATE, OID.TIMESTAMP, OID.TIMESTAMPTZ]);\n\nfunction pgKind(oid: number): FieldKind {\n  if (NUMERIC.has(oid)) return \"number\"; // pg returns int8/numeric as strings; buildChartData coerces\n  if (TEMPORAL.has(oid)) return \"time\";\n  if (oid === OID.BOOL) return \"boolean\";\n  return \"string\"; // text/varchar/json/uuid/time/arrays (stringified) ...\n}\n\n// pg parses date/timestamp columns to JS Date. For DATE, format from local components (pg builds the\n// Date at local midnight) to avoid a UTC day-shift; timestamps keep full ISO. Everything else uses\n// the shared default (numeric-string -> number, arrays/objects -> stringified).\nfunction pgNormalize(value: unknown, kind: FieldKind, column: SourceColumn): unknown {\n  if (kind === \"time\" && value instanceof Date) {\n    if (column.type === OID.DATE) {\n      const y = value.getFullYear();\n      const m = String(value.getMonth() + 1).padStart(2, \"0\");\n      const d = String(value.getDate()).padStart(2, \"0\");\n      return `${y}-${m}-${d}`;\n    }\n    return value.toISOString();\n  }\n  return defaultNormalizeCell(value, kind);\n}\n\n/** A Postgres result column: name + the type OID (`dataTypeID` from pg/PGlite result `fields`). */\nexport interface PostgresField {\n  name: string;\n  dataTypeID: number;\n}\n\n/**\n * Convert a Postgres result into ChartData.\n * @param rows   Result rows (objects), as returned by node-postgres or PGlite (`result.rows`).\n * @param fields Result columns (`result.fields`: name + dataTypeID).\n */\nexport function postgresToChartData(rows: Record<string, unknown>[], fields: PostgresField[]): ChartData {\n  const columns: SourceColumn[] = fields.map((f) => ({ name: f.name, type: f.dataTypeID }));\n  return buildChartData({ rows, columns, mapKind: (oid) => pgKind(oid as number), normalizeCell: pgNormalize });\n}\n","// @bonnard/mcp-charts/postgres — drop-in Postgres adapter for addCharts. Works with any\n// Postgres-wire endpoint, including a Cube SQL API or a Redshift cluster.\n//\n// The caller owns the pool + credentials; this packages the dev-side `runSql`: each query runs\n// inside a `READ ONLY` transaction so Postgres itself rejects writes, plus the result -> ChartData\n// transform. A read-only database role is still the real boundary.\n//\n//   import { addCharts } from \"@bonnard/mcp-charts\";\n//   import { postgresRunSql } from \"@bonnard/mcp-charts/postgres\";\n//   import { Pool } from \"pg\";\n//\n//   const pool = new Pool({ connectionString: process.env.DATABASE_URL });\n//   addCharts(server, { runSql: postgresRunSql(pool), discovery: { toolName: \"explore_schema\" } });\n//\n// `pg` is an OPTIONAL peer — only needed if you import this subpath. The type import below is erased\n// at build, and the OID map is self-contained, so this module adds no runtime dependency.\nimport type { Pool } from \"pg\";\nimport type { ChartData } from \"./types.js\";\nimport { assertReadOnlySql } from \"./adapters/sql.js\";\nimport { postgresToChartData } from \"./adapters/postgres.js\";\n\nexport { postgresToChartData, type PostgresField } from \"./adapters/postgres.js\";\n\nexport interface PostgresRunSqlOptions {\n  /** Reject non-SELECT statements + run inside a READ ONLY transaction. Default: true. */\n  readOnly?: boolean;\n}\n\n/** Build the `runSql` callback for `addCharts` from a pg Pool. */\nexport function postgresRunSql(pool: Pool, opts: PostgresRunSqlOptions = {}): (sql: string) => Promise<ChartData> {\n  const readOnly = opts.readOnly !== false;\n  return async (sql: string): Promise<ChartData> => {\n    if (readOnly) assertReadOnlySql(sql);\n    // A dedicated connection so BEGIN/ROLLBACK bracket the same session (a Pool may round-robin).\n    const client = await pool.connect();\n    try {\n      if (readOnly) await client.query(\"BEGIN TRANSACTION READ ONLY\");\n      const res = await client.query(sql);\n      if (readOnly) await client.query(\"ROLLBACK\");\n      return postgresToChartData(res.rows, res.fields);\n    } catch (err) {\n      if (readOnly) await client.query(\"ROLLBACK\").catch(() => {});\n      throw err;\n    } finally {\n      client.release();\n    }\n  };\n}\n"],"mappings":";;;;;;;AAQA,IAAM,MAAM;AAAA,EACV,MAAM;AAAA,EACN,MAAM;AAAA,EACN,MAAM;AAAA,EACN,MAAM;AAAA,EACN,KAAK;AAAA,EACL,QAAQ;AAAA,EACR,QAAQ;AAAA,EACR,SAAS;AAAA,EACT,MAAM;AAAA,EACN,WAAW;AAAA,EACX,aAAa;AACf;AAEA,IAAM,UAAU,oBAAI,IAAY,CAAC,IAAI,MAAM,IAAI,MAAM,IAAI,MAAM,IAAI,KAAK,IAAI,QAAQ,IAAI,QAAQ,IAAI,OAAO,CAAC;AAC5G,IAAM,WAAW,oBAAI,IAAY,CAAC,IAAI,MAAM,IAAI,WAAW,IAAI,WAAW,CAAC;AAE3E,SAAS,OAAO,KAAwB;AACtC,MAAI,QAAQ,IAAI,GAAG,EAAG,QAAO;AAC7B,MAAI,SAAS,IAAI,GAAG,EAAG,QAAO;AAC9B,MAAI,QAAQ,IAAI,KAAM,QAAO;AAC7B,SAAO;AACT;AAKA,SAAS,YAAY,OAAgB,MAAiB,QAA+B;AACnF,MAAI,SAAS,UAAU,iBAAiB,MAAM;AAC5C,QAAI,OAAO,SAAS,IAAI,MAAM;AAC5B,YAAM,IAAI,MAAM,YAAY;AAC5B,YAAM,IAAI,OAAO,MAAM,SAAS,IAAI,CAAC,EAAE,SAAS,GAAG,GAAG;AACtD,YAAM,IAAI,OAAO,MAAM,QAAQ,CAAC,EAAE,SAAS,GAAG,GAAG;AACjD,aAAO,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC;AAAA,IACvB;AACA,WAAO,MAAM,YAAY;AAAA,EAC3B;AACA,SAAO,qBAAqB,OAAO,IAAI;AACzC;AAaO,SAAS,oBAAoB,MAAiC,QAAoC;AACvG,QAAM,UAA0B,OAAO,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,MAAM,EAAE,WAAW,EAAE;AACxF,SAAO,eAAe,EAAE,MAAM,SAAS,SAAS,CAAC,QAAQ,OAAO,GAAa,GAAG,eAAe,YAAY,CAAC;AAC9G;;;ACjCO,SAAS,eAAe,MAAY,OAA8B,CAAC,GAAwC;AAChH,QAAM,WAAW,KAAK,aAAa;AACnC,SAAO,OAAO,QAAoC;AAChD,QAAI,SAAU,mBAAkB,GAAG;AAEnC,UAAM,SAAS,MAAM,KAAK,QAAQ;AAClC,QAAI;AACF,UAAI,SAAU,OAAM,OAAO,MAAM,6BAA6B;AAC9D,YAAM,MAAM,MAAM,OAAO,MAAM,GAAG;AAClC,UAAI,SAAU,OAAM,OAAO,MAAM,UAAU;AAC3C,aAAO,oBAAoB,IAAI,MAAM,IAAI,MAAM;AAAA,IACjD,SAAS,KAAK;AACZ,UAAI,SAAU,OAAM,OAAO,MAAM,UAAU,EAAE,MAAM,MAAM;AAAA,MAAC,CAAC;AAC3D,YAAM;AAAA,IACR,UAAE;AACA,aAAO,QAAQ;AAAA,IACjB;AAAA,EACF;AACF;","names":[]}

package/dist/snowflake.d.ts

@@ -0,0 +1,23 @@
+import { Connection } from 'snowflake-sdk';
+import { C as ChartData } from './types-CHiUU9mj.js';
+
+/** A Snowflake result column: name + the logical type from `Column.getType()`. */
+interface SnowflakeColumn {
+    name: string;
+    type: string;
+}
+/**
+ * Convert a Snowflake result into ChartData.
+ * @param rows    Row objects from the `complete(err, stmt, rows)` callback (rowMode "object").
+ * @param columns Column name + logical type, from `stmt.getColumns().map(c => ({ name: c.getName(), type: c.getType() }))`.
+ */
+declare function snowflakeToChartData(rows: Record<string, unknown>[], columns: SnowflakeColumn[]): ChartData;
+
+interface SnowflakeRunSqlOptions {
+    /** Reject non-SELECT statements. Default: true. A read-only role is the real boundary. */
+    readOnly?: boolean;
+}
+/** Build the `runSql` callback for `addCharts` from a connected snowflake-sdk Connection. */
+declare function snowflakeRunSql(connection: Connection, opts?: SnowflakeRunSqlOptions): (sql: string) => Promise<ChartData>;
+
+export { type SnowflakeColumn, type SnowflakeRunSqlOptions, snowflakeRunSql, snowflakeToChartData };

package/dist/snowflake.js

@@ -0,0 +1,65 @@
+import {
+  assertReadOnlySql,
+  buildChartData,
+  defaultNormalizeCell
+} from "./chunk-NGXV4I2L.js";
+
+// src/adapters/snowflake.ts
+var NUMERIC = /* @__PURE__ */ new Set(["fixed", "real"]);
+var TEMPORAL = /* @__PURE__ */ new Set(["date", "timestamp_ltz", "timestamp_ntz", "timestamp_tz"]);
+function snowflakeKind(type) {
+  const t = type.toLowerCase();
+  if (NUMERIC.has(t)) return "number";
+  if (TEMPORAL.has(t)) return "time";
+  if (t === "boolean") return "boolean";
+  return "string";
+}
+function snowflakeNormalize(value, kind, column) {
+  if (kind === "time" && value instanceof Date && String(column.type).toLowerCase() === "date") {
+    const y = value.getUTCFullYear();
+    const m = String(value.getUTCMonth() + 1).padStart(2, "0");
+    const d = String(value.getUTCDate()).padStart(2, "0");
+    return `${y}-${m}-${d}`;
+  }
+  return defaultNormalizeCell(value, kind);
+}
+function snowflakeToChartData(rows, columns) {
+  const cols = columns.map((c) => ({ name: c.name, type: c.type }));
+  return buildChartData({
+    rows,
+    columns: cols,
+    mapKind: (type) => snowflakeKind(type),
+    normalizeCell: snowflakeNormalize
+  });
+}
+
+// src/snowflake.ts
+function snowflakeRunSql(connection, opts = {}) {
+  const readOnly = opts.readOnly !== false;
+  return (sql) => new Promise((resolve, reject) => {
+    if (readOnly) {
+      try {
+        assertReadOnlySql(sql);
+      } catch (err) {
+        reject(err instanceof Error ? err : new Error(String(err)));
+        return;
+      }
+    }
+    connection.execute({
+      sqlText: sql,
+      complete: (err, stmt, rows) => {
+        if (err) {
+          reject(err);
+          return;
+        }
+        const columns = (stmt.getColumns() ?? []).map((c) => ({ name: c.getName(), type: c.getType() }));
+        resolve(snowflakeToChartData(rows ?? [], columns));
+      }
+    });
+  });
+}
+export {
+  snowflakeRunSql,
+  snowflakeToChartData
+};
+//# sourceMappingURL=snowflake.js.map

package/dist/snowflake.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/adapters/snowflake.ts","../src/snowflake.ts"],"sourcesContent":["// Snowflake -> ChartData. Engine-specific only: map Snowflake's logical column types (as reported\n// by snowflake-sdk's Column.getType()) to FieldKind, plus date-safe normalization. FieldMeta\n// assembly + ChartData shape come from ./sql.\nimport type { ChartData, FieldKind } from \"../types.js\";\nimport { buildChartData, defaultNormalizeCell, type SourceColumn } from \"./sql.js\";\n\n// snowflake-sdk Column.getType() returns lowercase logical types:\n// NUMBER/DECIMAL/INT -> \"fixed\", FLOAT/DOUBLE -> \"real\", VARCHAR/STRING -> \"text\", etc.\nconst NUMERIC = new Set([\"fixed\", \"real\"]);\nconst TEMPORAL = new Set([\"date\", \"timestamp_ltz\", \"timestamp_ntz\", \"timestamp_tz\"]);\n\nfunction snowflakeKind(type: string): FieldKind {\n  const t = type.toLowerCase();\n  if (NUMERIC.has(t)) return \"number\";\n  if (TEMPORAL.has(t)) return \"time\";\n  if (t === \"boolean\") return \"boolean\";\n  return \"string\"; // text, time, variant, object, array, binary, ...\n}\n\n// Snowflake DATE columns come back as JS Date (UTC midnight); keep the calendar day. Timestamps\n// keep full ISO. Everything else uses the shared default (numeric coercion, non-scalar stringify).\nfunction snowflakeNormalize(value: unknown, kind: FieldKind, column: SourceColumn): unknown {\n  if (kind === \"time\" && value instanceof Date && String(column.type).toLowerCase() === \"date\") {\n    const y = value.getUTCFullYear();\n    const m = String(value.getUTCMonth() + 1).padStart(2, \"0\");\n    const d = String(value.getUTCDate()).padStart(2, \"0\");\n    return `${y}-${m}-${d}`;\n  }\n  return defaultNormalizeCell(value, kind);\n}\n\n/** A Snowflake result column: name + the logical type from `Column.getType()`. */\nexport interface SnowflakeColumn {\n  name: string;\n  type: string;\n}\n\n/**\n * Convert a Snowflake result into ChartData.\n * @param rows    Row objects from the `complete(err, stmt, rows)` callback (rowMode \"object\").\n * @param columns Column name + logical type, from `stmt.getColumns().map(c => ({ name: c.getName(), type: c.getType() }))`.\n */\nexport function snowflakeToChartData(rows: Record<string, unknown>[], columns: SnowflakeColumn[]): ChartData {\n  const cols: SourceColumn[] = columns.map((c) => ({ name: c.name, type: c.type }));\n  return buildChartData({\n    rows,\n    columns: cols,\n    mapKind: (type) => snowflakeKind(type as string),\n    normalizeCell: snowflakeNormalize,\n  });\n}\n","// @bonnard/mcp-charts/snowflake — drop-in Snowflake adapter for addCharts.\n//\n// The caller owns the connection + auth; this packages the dev-side `runSql`: a read-only check\n// plus the result -> ChartData transform. Use a read-only role / warehouse as the real boundary.\n//\n//   import { addCharts } from \"@bonnard/mcp-charts\";\n//   import { snowflakeRunSql } from \"@bonnard/mcp-charts/snowflake\";\n//   import snowflake from \"snowflake-sdk\";\n//\n//   const connection = snowflake.createConnection({ account, username, ... });\n//   await new Promise((res, rej) => connection.connect((e) => (e ? rej(e) : res(null))));\n//   addCharts(server, { runSql: snowflakeRunSql(connection), discovery: { toolName: \"explore_schema\" } });\n//\n// `snowflake-sdk` is an OPTIONAL peer — only needed if you import this subpath.\nimport type { Connection } from \"snowflake-sdk\";\nimport type { ChartData } from \"./types.js\";\nimport { assertReadOnlySql } from \"./adapters/sql.js\";\nimport { snowflakeToChartData } from \"./adapters/snowflake.js\";\n\nexport { snowflakeToChartData, type SnowflakeColumn } from \"./adapters/snowflake.js\";\n\nexport interface SnowflakeRunSqlOptions {\n  /** Reject non-SELECT statements. Default: true. A read-only role is the real boundary. */\n  readOnly?: boolean;\n}\n\n/** Build the `runSql` callback for `addCharts` from a connected snowflake-sdk Connection. */\nexport function snowflakeRunSql(\n  connection: Connection,\n  opts: SnowflakeRunSqlOptions = {},\n): (sql: string) => Promise<ChartData> {\n  const readOnly = opts.readOnly !== false;\n  return (sql: string): Promise<ChartData> =>\n    new Promise<ChartData>((resolve, reject) => {\n      if (readOnly) {\n        try {\n          assertReadOnlySql(sql);\n        } catch (err) {\n          reject(err instanceof Error ? err : new Error(String(err)));\n          return;\n        }\n      }\n      connection.execute({\n        sqlText: sql,\n        complete: (err, stmt, rows) => {\n          if (err) {\n            reject(err);\n            return;\n          }\n          const columns = (stmt.getColumns() ?? []).map((c) => ({ name: c.getName(), type: c.getType() }));\n          resolve(snowflakeToChartData((rows ?? []) as Record<string, unknown>[], columns));\n        },\n      });\n    });\n}\n"],"mappings":";;;;;;;AAQA,IAAM,UAAU,oBAAI,IAAI,CAAC,SAAS,MAAM,CAAC;AACzC,IAAM,WAAW,oBAAI,IAAI,CAAC,QAAQ,iBAAiB,iBAAiB,cAAc,CAAC;AAEnF,SAAS,cAAc,MAAyB;AAC9C,QAAM,IAAI,KAAK,YAAY;AAC3B,MAAI,QAAQ,IAAI,CAAC,EAAG,QAAO;AAC3B,MAAI,SAAS,IAAI,CAAC,EAAG,QAAO;AAC5B,MAAI,MAAM,UAAW,QAAO;AAC5B,SAAO;AACT;AAIA,SAAS,mBAAmB,OAAgB,MAAiB,QAA+B;AAC1F,MAAI,SAAS,UAAU,iBAAiB,QAAQ,OAAO,OAAO,IAAI,EAAE,YAAY,MAAM,QAAQ;AAC5F,UAAM,IAAI,MAAM,eAAe;AAC/B,UAAM,IAAI,OAAO,MAAM,YAAY,IAAI,CAAC,EAAE,SAAS,GAAG,GAAG;AACzD,UAAM,IAAI,OAAO,MAAM,WAAW,CAAC,EAAE,SAAS,GAAG,GAAG;AACpD,WAAO,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC;AAAA,EACvB;AACA,SAAO,qBAAqB,OAAO,IAAI;AACzC;AAaO,SAAS,qBAAqB,MAAiC,SAAuC;AAC3G,QAAM,OAAuB,QAAQ,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,MAAM,EAAE,KAAK,EAAE;AAChF,SAAO,eAAe;AAAA,IACpB;AAAA,IACA,SAAS;AAAA,IACT,SAAS,CAAC,SAAS,cAAc,IAAc;AAAA,IAC/C,eAAe;AAAA,EACjB,CAAC;AACH;;;ACvBO,SAAS,gBACd,YACA,OAA+B,CAAC,GACK;AACrC,QAAM,WAAW,KAAK,aAAa;AACnC,SAAO,CAAC,QACN,IAAI,QAAmB,CAAC,SAAS,WAAW;AAC1C,QAAI,UAAU;AACZ,UAAI;AACF,0BAAkB,GAAG;AAAA,MACvB,SAAS,KAAK;AACZ,eAAO,eAAe,QAAQ,MAAM,IAAI,MAAM,OAAO,GAAG,CAAC,CAAC;AAC1D;AAAA,MACF;AAAA,IACF;AACA,eAAW,QAAQ;AAAA,MACjB,SAAS;AAAA,MACT,UAAU,CAAC,KAAK,MAAM,SAAS;AAC7B,YAAI,KAAK;AACP,iBAAO,GAAG;AACV;AAAA,QACF;AACA,cAAM,WAAW,KAAK,WAAW,KAAK,CAAC,GAAG,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,GAAG,MAAM,EAAE,QAAQ,EAAE,EAAE;AAC/F,gBAAQ,qBAAsB,QAAQ,CAAC,GAAiC,OAAO,CAAC;AAAA,MAClF;AAAA,IACF,CAAC;AAAA,EACH,CAAC;AACL;","names":[]}

package/dist/types-CHiUU9mj.d.ts

@@ -0,0 +1,115 @@
+type ChartType = "line" | "bar" | "area" | "pie" | "scatter" | "funnel" | "waterfall" | "table";
+/** What a field IS, for charting purposes. */
+type FieldRole = "measure" | "dimension" | "time";
+type FieldKind = "number" | "string" | "time" | "boolean";
+type FieldFormat = "number" | "currency" | "percent";
+type TimeGranularity = "day" | "week" | "month" | "quarter" | "year";
+/** Per-field typing — the metadata `resolve()` needs. Semantic layers supply this for
+ *  free; SQL drivers supply name + kind; ORM/custom devs declare it once. */
+interface FieldMeta {
+    name: string;
+    role?: FieldRole;
+    kind?: FieldKind;
+    format?: FieldFormat;
+    label?: string;
+    granularity?: TimeGranularity;
+    additive?: boolean;
+    currency?: string;
+}
+/** Explicit encoding override, when field names don't make x/y/series obvious. */
+interface Encode {
+    x?: string;
+    y?: string | string[];
+    series?: string;
+    /** Measure(s) to plot on a secondary (right) y-axis, drawn as a line over the primary chart. */
+    y2?: string | string[];
+    /** Measure(s) to draw as a line instead of bars on the SAME axis (a combo, e.g. actual vs target). */
+    line?: string | string[];
+    /** Scatter only: a 3rd measure mapped to point size (turns a scatter into a bubble chart). */
+    size?: string;
+}
+/** The normalized result every data callback returns. */
+interface ChartData {
+    rows: Record<string, unknown>[];
+    fields?: FieldMeta[];
+    encode?: Encode;
+}
+/** Context passed to data callbacks — extensible bag so the signature never breaks. */
+interface ChartContext {
+    tenant?: string;
+    roles?: string[];
+    userId?: string;
+    requestId?: string;
+    signal?: AbortSignal;
+}
+type Stacking = "stacked" | "grouped" | "stacked100";
+interface SeriesSpec {
+    key: string;
+    label: string;
+    /** Which y-axis this series belongs to. "right" series render as a line (dual-axis combo). */
+    axis?: "left" | "right";
+    /** Render this series as a line instead of the chart's base type (same-axis combo). */
+    type?: "bar" | "line";
+}
+interface AxisSpec {
+    label?: string;
+    format?: FieldFormat;
+    granularity?: TimeGranularity;
+    currency?: string;
+    /** x-axis only: values are numeric, so line/area render on a linear (value) scale, not categories. */
+    numeric?: boolean;
+}
+interface ColumnSpec {
+    key: string;
+    label: string;
+    format?: FieldFormat;
+    granularity?: TimeGranularity;
+    currency?: string;
+}
+/** A horizontal reference line on the value axis (target, average, threshold). */
+interface ReferenceLine {
+    value: number;
+    label: string;
+}
+/** Output of resolve() — everything a renderer needs, fully serializable. */
+interface ChartSpec {
+    chartType: ChartType;
+    /** Cleaned + (if needed) pivoted/time-filled rows, ready to plot. */
+    data: Record<string, unknown>[];
+    /** x-axis key ("" for a single-measure table). */
+    x: string;
+    series: SeriesSpec[];
+    xAxis?: AxisSpec;
+    yAxis?: AxisSpec;
+    /** Secondary (right) y-axis descriptor, present only for dual-axis combo charts. */
+    yAxisRight?: AxisSpec;
+    legend: boolean;
+    stacking?: Stacking;
+    horizontal?: boolean;
+    title?: string;
+    columns?: ColumnSpec[];
+    /** Horizontal reference lines on the value axis (target / average). */
+    reference?: ReferenceLine[];
+    /** Scatter only: column mapped to point size (bubble chart). */
+    size?: string;
+    /** Scatter only: a dimension column used to label/identify each point (tooltip). */
+    pointLabel?: string;
+    /** Waterfall only: step labels that are totals (full bars anchored at 0), not floating deltas. */
+    totals?: string[];
+    /** Non-fatal advisories about how the data was massaged (e.g. summed unaggregated rows). */
+    notes?: string[];
+}
+/** Options to resolve(), typically sourced from the agent's tool args. */
+interface ResolveOptions {
+    chartType?: ChartType | "auto";
+    title?: string;
+    stacking?: Stacking;
+    horizontal?: boolean;
+    /** Add reference lines: an average (computed) and/or a target (a value you pass). */
+    reference?: {
+        target?: number;
+        average?: boolean;
+    };
+}
+
+export type { AxisSpec as A, ChartData as C, Encode as E, FieldMeta as F, ResolveOptions as R, SeriesSpec as S, TimeGranularity as T, ChartSpec as a, ChartContext as b, ChartType as c, FieldKind as d, ColumnSpec as e, FieldFormat as f, FieldRole as g, ReferenceLine as h, Stacking as i };

package/package.json

@@ -0,0 +1,109 @@
+{
+  "name": "@bonnard/mcp-charts",
+  "version": "0.1.1",
+  "description": "Add beautiful, agent-ready charts to your MCP server in a few lines.",
+  "type": "module",
+  "license": "MIT",
+  "author": "Bonnard (bonnard-data)",
+  "homepage": "https://github.com/bonnard-data/mcp-charts#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bonnard-data/mcp-charts.git",
+    "directory": "packages/core"
+  },
+  "bugs": {
+    "url": "https://github.com/bonnard-data/mcp-charts/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./bigquery": {
+      "types": "./dist/bigquery.d.ts",
+      "import": "./dist/bigquery.js"
+    },
+    "./duckdb": {
+      "types": "./dist/duckdb.d.ts",
+      "import": "./dist/duckdb.js"
+    },
+    "./postgres": {
+      "types": "./dist/postgres.d.ts",
+      "import": "./dist/postgres.js"
+    },
+    "./snowflake": {
+      "types": "./dist/snowflake.d.ts",
+      "import": "./dist/snowflake.js"
+    },
+    "./databricks": {
+      "types": "./dist/databricks.d.ts",
+      "import": "./dist/databricks.js"
+    }
+  },
+  "scripts": {
+    "embed": "node scripts/embed-widget.mjs",
+    "prebuild": "node scripts/embed-widget.mjs",
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "check:exports": "publint && attw --pack . --profile esm-only"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "charts",
+    "visualization",
+    "mcp-apps",
+    "ai"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "peerDependencies": {
+    "@databricks/sql": "^1.0.0",
+    "@duckdb/node-api": "^1.0.0",
+    "@google-cloud/bigquery": "^7.0.0 || ^8.0.0",
+    "@modelcontextprotocol/sdk": ">=1.27.0",
+    "pg": "^8.0.0",
+    "snowflake-sdk": "^1.9.0 || ^2.0.0 || ^3.0.0",
+    "zod": "^3.25.0 || ^4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@databricks/sql": {
+      "optional": true
+    },
+    "@duckdb/node-api": {
+      "optional": true
+    },
+    "@google-cloud/bigquery": {
+      "optional": true
+    },
+    "pg": {
+      "optional": true
+    },
+    "snowflake-sdk": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.18.3",
+    "@databricks/sql": "^1.16.0",
+    "@duckdb/node-api": "1.5.4-r.1",
+    "@electric-sql/pglite": "^0.5.3",
+    "@google-cloud/bigquery": "^8.3.1",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@types/node": "^20.0.0",
+    "@types/pg": "^8.20.0",
+    "publint": "^0.3.21",
+    "snowflake-sdk": "^3.0.0",
+    "tsup": "^8.5.0",
+    "vitest": "^3.2.0",
+    "zod": "^4.4.0"
+  }
+}