@aivue/tabular-intelligence 1.0.0 → 1.2.0

package/dist/index.mjs

@@ -1,16 +1,545 @@
-import { ref as M } from "vue";
-class N {
-  constructor(s) {
+import { ref as E, defineComponent as z, createElementBlock as h, openBlock as f, createElementVNode as m, createCommentVNode as S, withDirectives as Z, withKeys as V, withModifiers as R, vModelText as ee, toDisplayString as A, normalizeClass as te, createTextVNode as ne, Fragment as O, renderList as Q, computed as se } from "vue";
+function N(c, e) {
+  if (c.length === 0)
+    return { columns: [], rowCount: 0, name: e };
+  const t = c[0];
+  return {
+    columns: Object.keys(t).map((s) => {
+      const a = L(c, s);
+      return {
+        name: s,
+        type: a,
+        nullable: c.some((o) => o[s] == null)
+      };
+    }),
+    rowCount: c.length,
+    name: e
+  };
+}
+function L(c, e) {
+  const t = c.map((s) => s[e]).filter((s) => s != null);
+  if (t.length === 0) return "string";
+  if (t.every((s) => typeof s == "number" || !isNaN(Number(s))))
+    return "number";
+  if (t.every((s) => typeof s == "boolean" || s === "true" || s === "false"))
+    return "boolean";
+  if (t.every((s) => !isNaN(Date.parse(s))))
+    return "date";
+  const n = new Set(t);
+  return n.size < t.length * 0.5 && n.size < 20 ? "categorical" : "string";
+}
+function B(c, e, t) {
+  const n = c.map((r) => r[e]).filter((r) => r != null), s = n.length, a = c.length - s, o = {
+    column: e,
+    count: s,
+    nullCount: a
+  };
+  if (t === "number") {
+    const r = n.map(Number).filter((i) => !isNaN(i));
+    if (r.length > 0) {
+      const i = [...r].sort((p, d) => p - d), l = r.reduce((p, d) => p + d, 0);
+      o.mean = l / r.length, o.median = i[Math.floor(i.length / 2)], o.min = i[0], o.max = i[i.length - 1];
+      const g = r.reduce((p, d) => p + Math.pow(d - o.mean, 2), 0) / r.length;
+      o.std = Math.sqrt(g), o.percentiles = {
+        25: i[Math.floor(i.length * 0.25)],
+        50: o.median,
+        75: i[Math.floor(i.length * 0.75)],
+        90: i[Math.floor(i.length * 0.9)]
+      };
+    }
+  } else {
+    const r = new Set(n);
+    o.uniqueValues = r.size;
+    const i = {};
+    n.forEach((g) => {
+      const p = String(g);
+      i[p] = (i[p] || 0) + 1;
+    });
+    const l = Math.max(...Object.values(i));
+    o.mode = Object.keys(i).find((g) => i[g] === l);
+  }
+  return o;
+}
+function ae(c, e, t = 0.5) {
+  const n = [], s = 1.5 + (1 - t) * 1.5;
+  return e.forEach((a) => {
+    const o = c.map((y, v) => ({ value: Number(y[a]), idx: v })).filter((y) => !isNaN(y.value));
+    if (o.length === 0) return;
+    const r = [...o].sort((y, v) => y.value - v.value), i = r[Math.floor(r.length * 0.25)].value, l = r[Math.floor(r.length * 0.75)].value, g = l - i, p = i - s * g, d = l + s * g;
+    o.forEach(({ value: y, idx: v }) => {
+      if (y < p || y > d) {
+        const $ = n.find((D) => D.rowIndex === v), C = y < p ? `${a}: ${y.toFixed(2)} < ${p.toFixed(2)}` : `${a}: ${y.toFixed(2)} > ${d.toFixed(2)}`;
+        $ ? ($.reasons.push(C), $.affectedColumns.push(a), $.score = Math.min(1, $.score + 0.2)) : n.push({
+          rowIndex: v,
+          row: c[v],
+          score: 0.7,
+          reasons: [C],
+          affectedColumns: [a]
+        });
+      }
+    });
+  }), n.sort((a, o) => o.score - a.score);
+}
+class H {
+  constructor(e) {
     this.config = {
-      timeout: 3e4,
-      ...s
+      maxTokens: 1e3,
+      temperature: 0.3,
+      ...e
+    };
+  }
+  /**
+   * Answer a question about the table data
+   */
+  async answerQuestion(e) {
+    const t = Date.now();
+    try {
+      const { question: n, schema: s, data: a = [], sampleSize: o = 100, includeAggregates: r = !0 } = e, i = a.length > o ? this.sampleData(a, o) : a, l = r ? this.calculateAggregates(a, s) : void 0, g = this.buildPrompt(n, s, i, l, a.length), p = await this.callLLM(g);
+      return {
+        answer: this.parseResponse(p, n, a.length > o),
+        processingTime: Date.now() - t
+      };
+    } catch (n) {
+      return console.error("Q&A error:", n), {
+        answer: {
+          questionId: this.generateId(),
+          text: "I encountered an error while processing your question. Please try again.",
+          timestamp: /* @__PURE__ */ new Date(),
+          confidence: 0,
+          cannotAnswer: !0,
+          reason: n instanceof Error ? n.message : "Unknown error"
+        },
+        processingTime: Date.now() - t
+      };
+    }
+  }
+  /**
+   * Sample data for large datasets
+   */
+  sampleData(e, t) {
+    if (e.length <= t)
+      return e;
+    const n = Math.floor(e.length / t), s = [];
+    for (let a = 0; a < e.length && s.length < t; a += n)
+      s.push(e[a]);
+    return s;
+  }
+  /**
+   * Calculate aggregates for numeric columns
+   */
+  calculateAggregates(e, t) {
+    const n = {};
+    for (const s of t.columns)
+      if (s.type === "number" && e.length > 0)
+        try {
+          const a = B(e, s.name, "number");
+          n[s.name] = {
+            mean: a.mean,
+            median: a.median,
+            min: a.min,
+            max: a.max,
+            count: a.count
+          };
+        } catch {
+        }
+      else if (s.type === "categorical" || s.type === "string") {
+        const a = e.map((r) => r[s.name]).filter((r) => r != null), o = new Set(a);
+        n[s.name] = {
+          uniqueCount: o.size,
+          totalCount: a.length,
+          topValues: this.getTopValues(a, 5)
+        };
+      }
+    return n;
+  }
+  /**
+   * Get top N most frequent values
+   */
+  getTopValues(e, t) {
+    const n = /* @__PURE__ */ new Map();
+    for (const s of e)
+      n.set(s, (n.get(s) || 0) + 1);
+    return Array.from(n.entries()).map(([s, a]) => ({ value: s, count: a })).sort((s, a) => a.count - s.count).slice(0, t);
+  }
+  /**
+   * Build prompt for LLM
+   */
+  buildPrompt(e, t, n, s, a) {
+    const o = a && a > n.length;
+    let r = `You are a data analyst assistant. Answer the following question about a table dataset.
+
+`;
+    r += `**Table Schema:**
+`, r += `Table: ${t.name}
+`, r += `Columns:
+`;
+    for (const i of t.columns)
+      r += `- ${i.name} (${i.type})
+`;
+    return r += `
+`, s && Object.keys(s).length > 0 && (r += `**Summary Statistics:**
+`, r += JSON.stringify(s, null, 2), r += `
+
+`), r += `**Sample Data** (${n.length} rows${o ? ` out of ${a} total` : ""}):
+`, r += JSON.stringify(n.slice(0, 10), null, 2), r += `
+
+`, r += `**Question:** ${e}
+
+`, r += `**Instructions:**
+`, r += `1. Answer ONLY based on the data provided above.
+`, r += `2. If the question cannot be answered from the available data, clearly state "I cannot answer this question from the available data" and explain why.
+`, r += `3. Provide a clear, concise answer.
+`, r += `4. Include specific numbers or examples from the data when relevant.
+`, r += `5. If the answer is based on sampled data, mention that it's an approximation.
+`, r += `6. Format your response as JSON with the following structure:
+`, r += `{
+`, r += `  "answer": "Your answer text here",
+`, r += `  "confidence": 0.0-1.0,
+`, r += `  "cannotAnswer": false,
+`, r += `  "isApproximate": ${o},
+`, r += `  "supportingData": { "key": "value" } // optional
+`, r += `}
+`, r;
+  }
+  /**
+   * Call LLM API
+   */
+  async callLLM(e) {
+    const { provider: t, apiKey: n, baseUrl: s, model: a, maxTokens: o, temperature: r } = this.config;
+    if (t === "openai")
+      return this.callOpenAI(e, n, a || "gpt-4-turbo-preview", o, r);
+    if (t === "anthropic")
+      return this.callAnthropic(e, n, a || "claude-3-5-sonnet-20241022", o, r);
+    if (t === "custom" && s)
+      return this.callCustomAPI(e, s, n);
+    throw new Error(`Unsupported provider: ${t}`);
+  }
+  /**
+   * Call OpenAI API
+   */
+  async callOpenAI(e, t, n, s, a) {
+    var i, l;
+    const o = await fetch("https://api.openai.com/v1/chat/completions", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${t}`
+      },
+      body: JSON.stringify({
+        model: n,
+        messages: [{ role: "user", content: e }],
+        max_tokens: s,
+        temperature: a,
+        response_format: { type: "json_object" }
+      })
+    });
+    if (!o.ok)
+      throw new Error(`OpenAI API error: ${o.statusText}`);
+    return ((l = (i = (await o.json()).choices[0]) == null ? void 0 : i.message) == null ? void 0 : l.content) || "";
+  }
+  /**
+   * Call Anthropic API
+   */
+  async callAnthropic(e, t, n, s, a) {
+    var i;
+    const o = await fetch("https://api.anthropic.com/v1/messages", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": t,
+        "anthropic-version": "2023-06-01"
+      },
+      body: JSON.stringify({
+        model: n,
+        max_tokens: s,
+        temperature: a,
+        messages: [{ role: "user", content: e }]
+      })
+    });
+    if (!o.ok)
+      throw new Error(`Anthropic API error: ${o.statusText}`);
+    return ((i = (await o.json()).content[0]) == null ? void 0 : i.text) || "";
+  }
+  /**
+   * Call custom API
+   */
+  async callCustomAPI(e, t, n) {
+    const s = {
+      "Content-Type": "application/json"
+    };
+    n && (s.Authorization = `Bearer ${n}`);
+    const a = await fetch(t, {
+      method: "POST",
+      headers: s,
+      body: JSON.stringify({ prompt: e })
+    });
+    if (!a.ok)
+      throw new Error(`Custom API error: ${a.statusText}`);
+    const o = await a.json();
+    return o.response || o.answer || JSON.stringify(o);
+  }
+  /**
+   * Parse LLM response
+   */
+  parseResponse(e, t, n) {
+    try {
+      const s = JSON.parse(e);
+      return {
+        questionId: this.generateId(),
+        text: s.answer || s.text || e,
+        timestamp: /* @__PURE__ */ new Date(),
+        confidence: s.confidence || 0.8,
+        cannotAnswer: s.cannotAnswer || !1,
+        isApproximate: s.isApproximate !== void 0 ? s.isApproximate : n,
+        supportingData: s.supportingData,
+        reason: s.reason
+      };
+    } catch {
+      return {
+        questionId: this.generateId(),
+        text: e,
+        timestamp: /* @__PURE__ */ new Date(),
+        confidence: 0.7,
+        isApproximate: n
+      };
+    }
+  }
+  /**
+   * Generate unique ID
+   */
+  generateId() {
+    return `qa_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+}
+function re(c = {}) {
+  const {
+    selector: e = "table",
+    includeHeaders: t = !0,
+    maxRows: n,
+    inferTypes: s = !0,
+    skipEmptyRows: a = !0
+  } = c, o = document.querySelector(e);
+  if (!o || o.tagName !== "TABLE")
+    return console.warn(`No table found with selector: ${e}`), null;
+  const i = Array.from(o.rows);
+  if (i.length === 0)
+    return null;
+  let l = [], g = 0;
+  if (t && i[0]) {
+    const v = i[0];
+    l = Array.from(v.cells).map(($, C) => {
+      var _;
+      return ((_ = $.textContent) == null ? void 0 : _.trim()) || "" || `Column${C + 1}`;
+    }), g = 1;
+  } else {
+    const v = i[0];
+    l = Array.from(v.cells).map(($, C) => `Column${C + 1}`);
+  }
+  const p = [], d = n ? i.slice(g, g + n) : i.slice(g);
+  for (const v of d) {
+    const $ = Array.from(v.cells);
+    if (a && $.every((D) => {
+      var _;
+      return !((_ = D.textContent) != null && _.trim());
+    }))
+      continue;
+    const C = {};
+    $.forEach((D, _) => {
+      var M;
+      const j = l[_] || `Column${_ + 1}`;
+      let T = ((M = D.textContent) == null ? void 0 : M.trim()) || "";
+      if (s && T) {
+        const P = parseFloat(T);
+        !isNaN(P) && T === P.toString() && (T = P);
+      }
+      C[j] = T;
+    }), p.push(C);
+  }
+  return {
+    schema: s && p.length > 0 ? N(p, "Extracted Table") : ie(l, p.length),
+    data: p,
+    source: "dom",
+    metadata: {
+      selector: e,
+      rowCount: p.length,
+      columnCount: l.length,
+      extractedAt: /* @__PURE__ */ new Date()
+    }
+  };
+}
+function oe(c, e, t = {}) {
+  const { maxRows: n, inferTypes: s = !0 } = t, a = n ? c.slice(0, n) : c;
+  let o;
+  return e && e.length > 0 ? o = {
+    name: "Vue Data Grid",
+    columns: e.map((r) => ({
+      name: r.field,
+      type: s && a.length > 0 ? L(a, r.field) : "string",
+      nullable: !0
+    })),
+    rowCount: a.length
+  } : a.length > 0 ? o = N(a, "Vue Data Grid") : o = { name: "Vue Data Grid", columns: [], rowCount: 0 }, {
+    schema: o,
+    data: a,
+    source: "vue",
+    metadata: {
+      rowCount: a.length,
+      columnCount: o.columns.length,
+      extractedAt: /* @__PURE__ */ new Date()
+    }
+  };
+}
+function ie(c, e = 0) {
+  return {
+    name: "Extracted Table",
+    columns: c.map((t) => ({
+      name: t,
+      type: "string",
+      nullable: !0
+    })),
+    rowCount: e
+  };
+}
+function ce(c) {
+  const e = {};
+  c.variable && c.variable.forEach((a) => {
+    e[a.key] = a.value;
+  });
+  const t = c.auth ? J(c.auth) : void 0, n = [];
+  function s(a, o = "") {
+    a.forEach((r) => {
+      r.item ? s(r.item, o ? `${o}/${r.name}` : r.name) : r.request && n.push(le(r, t));
+    });
+  }
+  return s(c.item), {
+    name: c.info.name,
+    description: c.info.description,
+    endpoints: n,
+    variables: e,
+    auth: t
+  };
+}
+function le(c, e) {
+  const t = c.request, n = {};
+  t.header && t.header.forEach((o) => {
+    n[o.key] = o.value;
+  });
+  const s = {};
+  t.url.query && t.url.query.forEach((o) => {
+    s[o.key] = o.value;
+  });
+  const a = t.auth ? J(t.auth) : e;
+  return {
+    name: c.name,
+    method: t.method,
+    url: t.url.raw,
+    description: t.description,
+    headers: n,
+    queryParams: s,
+    auth: a
+  };
+}
+function J(c) {
+  const e = {};
+  return c.apikey ? c.apikey.forEach((t) => {
+    e[t.key] = t.value;
+  }) : c.bearer ? c.bearer.forEach((t) => {
+    e[t.key] = t.value;
+  }) : c.basic && c.basic.forEach((t) => {
+    e[t.key] = t.value;
+  }), {
+    type: c.type,
+    credentials: e
+  };
+}
+function I(c, e) {
+  let t = c;
+  return Object.keys(e).forEach((n) => {
+    const s = new RegExp(`{{${n}}}`, "g");
+    t = t.replace(s, e[n]);
+  }), t;
+}
+async function U(c) {
+  const { endpoint: e, variables: t = {}, additionalHeaders: n = {}, additionalParams: s = {} } = c;
+  try {
+    let a = I(e.url, t);
+    const o = { ...e.queryParams, ...s }, r = Object.keys(o).map((d) => `${encodeURIComponent(d)}=${encodeURIComponent(I(o[d], t))}`).join("&");
+    r && (a = a.includes("?") ? `${a}&${r}` : `${a}?${r}`);
+    const i = {
+      "Content-Type": "application/json",
+      ...e.headers,
+      ...n
     };
+    if (Object.keys(i).forEach((d) => {
+      i[d] = I(i[d], t);
+    }), e.auth) {
+      if (e.auth.type === "apikey") {
+        const d = e.auth.credentials.key || "access_key", y = I(e.auth.credentials.value || "", t);
+        e.auth.credentials.in === "header" && (i[d] = y);
+      } else if (e.auth.type === "bearer") {
+        const d = I(e.auth.credentials.token || "", t);
+        i.Authorization = `Bearer ${d}`;
+      } else if (e.auth.type === "basic") {
+        const d = I(e.auth.credentials.username || "", t), y = I(e.auth.credentials.password || "", t), v = btoa(`${d}:${y}`);
+        i.Authorization = `Basic ${v}`;
+      }
+    }
+    const l = await fetch(a, {
+      method: e.method,
+      headers: i
+    }), g = {};
+    return l.headers.forEach((d, y) => {
+      g[y] = d;
+    }), l.ok ? {
+      success: !0,
+      data: await l.json(),
+      statusCode: l.status,
+      headers: g
+    } : {
+      success: !1,
+      error: `HTTP ${l.status}: ${l.statusText}`,
+      statusCode: l.status,
+      headers: g
+    };
+  } catch (a) {
+    return {
+      success: !1,
+      error: a.message || "Unknown error occurred"
+    };
+  }
+}
+async function Ge(c, e = {}) {
+  const t = [];
+  for (const n of c) {
+    const s = await U({ endpoint: n, variables: e });
+    t.push(s);
+  }
+  return t;
+}
+function ue(c) {
+  if (!c.success || !c.data)
+    return [];
+  const e = c.data;
+  return Array.isArray(e) ? e : e.data && Array.isArray(e.data) ? e.data : e.results && Array.isArray(e.results) ? e.results : e.items && Array.isArray(e.items) ? e.items : typeof e == "object" ? [e] : [];
+}
+class de {
+  constructor(e, t) {
+    this.config = {
+      timeout: 3e4,
+      ...e
+    }, t && (this.qaEngine = new H(t));
+  }
+  /**
+   * Initialize or update Q&A engine
+   */
+  initializeQA(e) {
+    this.qaEngine = new H(e);
   }
   /**
    * Generic API call to TFM endpoint
    */
-  async callTFM(s) {
-    const e = Date.now();
+  async callTFM(e) {
+    const t = Date.now();
     try {
       const n = await fetch(this.config.baseUrl, {
         method: "POST",
@@ -20,23 +549,23 @@ class N {
           ...this.config.headers
         },
         body: JSON.stringify({
-          ...s,
+          ...e,
           model: this.config.model
         }),
         signal: AbortSignal.timeout(this.config.timeout || 3e4)
       });
       if (!n.ok) {
-        const r = await n.text();
-        throw new Error(`TFM API error: ${n.status} - ${r}`);
+        const o = await n.text();
+        throw new Error(`TFM API error: ${n.status} - ${o}`);
       }
-      const t = await n.json(), i = Date.now() - e;
+      const s = await n.json(), a = Date.now() - t;
       return {
         success: !0,
-        result: t.result || t,
+        result: s.result || s,
         metadata: {
-          processingTime: i,
+          processingTime: a,
           model: this.config.model || "unknown",
-          version: t.version
+          version: s.version
         }
       };
     } catch (n) {
@@ -44,7 +573,7 @@ class N {
         success: !1,
         error: n instanceof Error ? n.message : "Unknown error",
         metadata: {
-          processingTime: Date.now() - e,
+          processingTime: Date.now() - t,
           model: this.config.model || "unknown"
         }
       };
@@ -53,255 +582,543 @@ class N {
   /**
    * Perform analysis on tabular data
    */
-  async analyze(s) {
-    const e = {
-      operation: s.type,
-      data: s.data,
-      schema: s.schema,
-      parameters: s.options
-    }, n = await this.callTFM(e);
+  async analyze(e) {
+    const t = {
+      operation: e.type,
+      data: e.data,
+      schema: e.schema,
+      parameters: e.options
+    }, n = await this.callTFM(t);
     if (!n.success)
       throw new Error(n.error || "Analysis failed");
-    return this.parseAnalysisResult(s.type, n.result, n.metadata);
+    return this.parseAnalysisResult(e.type, n.result, n.metadata);
   }
   /**
    * Parse TFM response into structured AnalysisResult
    */
-  parseAnalysisResult(s, e, n) {
-    const t = {
-      type: s,
+  parseAnalysisResult(e, t, n) {
+    const s = {
+      type: e,
       timestamp: /* @__PURE__ */ new Date(),
-      summary: e.summary || "",
-      insights: e.insights || [],
-      recommendations: e.recommendations,
-      confidence: e.confidence || 0.8,
+      summary: t.summary || "",
+      insights: t.insights || [],
+      recommendations: t.recommendations,
+      confidence: t.confidence || 0.8,
       processingTime: n == null ? void 0 : n.processingTime
     };
-    switch (s) {
+    switch (e) {
       case "descriptive_stats":
         return {
-          ...t,
-          descriptiveStats: e.stats || e.descriptiveStats
+          ...s,
+          descriptiveStats: t.stats || t.descriptiveStats
         };
       case "anomaly_detection":
         return {
-          ...t,
-          anomalies: e.anomalies || []
+          ...s,
+          anomalies: t.anomalies || []
         };
       case "segmentation":
       case "clustering":
         return {
-          ...t,
-          clusters: e.clusters || []
+          ...s,
+          clusters: t.clusters || []
         };
       case "prediction":
         return {
-          ...t,
-          predictions: e.predictions || e
+          ...s,
+          predictions: t.predictions || t
         };
       case "correlation":
         return {
-          ...t,
-          correlations: e.correlations || e
+          ...s,
+          correlations: t.correlations || t
+        };
+      case "summary":
+        return {
+          ...s,
+          aiSummary: t.summary || t
+        };
+      case "qa":
+        return {
+          ...s,
+          qaAnswer: t.answer || t
         };
       default:
-        return t;
+        return s;
     }
   }
+  /**
+   * Ask a question about the data (Q&A)
+   */
+  async askQuestion(e) {
+    if (!this.qaEngine)
+      throw new Error("Q&A engine not initialized. Call initializeQA() first.");
+    return this.qaEngine.answerQuestion(e);
+  }
+  /**
+   * Generate AI summary of table data
+   */
+  async generateSummary(e, t) {
+    const n = {
+      type: "summary",
+      data: e,
+      schema: t
+    }, s = await this.analyze(n);
+    if (!s.aiSummary)
+      throw new Error("Failed to generate summary");
+    return s.aiSummary;
+  }
+  /**
+   * Extract table from DOM
+   */
+  extractFromDOM(e) {
+    return re(e);
+  }
+  /**
+   * Normalize Vue data grid data
+   */
+  normalizeVueData(e, t, n) {
+    return oe(e, t, n);
+  }
   /**
    * Update configuration
    */
-  updateConfig(s) {
-    this.config = { ...this.config, ...s };
+  updateConfig(e) {
+    this.config = { ...this.config, ...e };
   }
   /**
    * Get current configuration (without sensitive data)
    */
   getConfig() {
-    const { apiKey: s, ...e } = this.config;
-    return e;
+    const { apiKey: e, ...t } = this.config;
+    return t;
   }
-}
-function T(c, s) {
-  if (c.length === 0)
-    return { columns: [], rowCount: 0, name: s };
-  const e = c[0];
-  return {
-    columns: Object.keys(e).map((t) => {
-      const i = $(c, t);
-      return {
-        name: t,
-        type: i,
-        nullable: c.some((r) => r[t] == null)
-      };
-    }),
-    rowCount: c.length,
-    name: s
-  };
-}
-function $(c, s) {
-  const e = c.map((t) => t[s]).filter((t) => t != null);
-  if (e.length === 0) return "string";
-  if (e.every((t) => typeof t == "number" || !isNaN(Number(t))))
-    return "number";
-  if (e.every((t) => typeof t == "boolean" || t === "true" || t === "false"))
-    return "boolean";
-  if (e.every((t) => !isNaN(Date.parse(t))))
-    return "date";
-  const n = new Set(e);
-  return n.size < e.length * 0.5 && n.size < 20 ? "categorical" : "string";
-}
-function A(c, s, e) {
-  const n = c.map((l) => l[s]).filter((l) => l != null), t = n.length, i = c.length - t, r = {
-    column: s,
-    count: t,
-    nullCount: i
-  };
-  if (e === "number") {
-    const l = n.map(Number).filter((o) => !isNaN(o));
-    if (l.length > 0) {
-      const o = [...l].sort((u, d) => u - d), p = l.reduce((u, d) => u + d, 0);
-      r.mean = p / l.length, r.median = o[Math.floor(o.length / 2)], r.min = o[0], r.max = o[o.length - 1];
-      const h = l.reduce((u, d) => u + Math.pow(d - r.mean, 2), 0) / l.length;
-      r.std = Math.sqrt(h), r.percentiles = {
-        25: o[Math.floor(o.length * 0.25)],
-        50: r.median,
-        75: o[Math.floor(o.length * 0.75)],
-        90: o[Math.floor(o.length * 0.9)]
-      };
-    }
-  } else {
-    const l = new Set(n);
-    r.uniqueValues = l.size;
-    const o = {};
-    n.forEach((h) => {
-      const u = String(h);
-      o[u] = (o[u] || 0) + 1;
-    });
-    const p = Math.max(...Object.values(o));
-    r.mode = Object.keys(o).find((h) => o[h] === p);
+  // ============================================================================
+  // API Integration Methods
+  // ============================================================================
+  /**
+   * Load Postman collection
+   */
+  loadPostmanCollection(e) {
+    return this.parsedCollection = ce(e), this.parsedCollection;
+  }
+  /**
+   * Get loaded collection
+   */
+  getCollection() {
+    return this.parsedCollection;
+  }
+  /**
+   * Get endpoints from loaded collection
+   */
+  getEndpoints() {
+    var e;
+    return ((e = this.parsedCollection) == null ? void 0 : e.endpoints) || [];
+  }
+  /**
+   * Execute API request and get data
+   */
+  async fetchDataFromAPI(e, t) {
+    if (!this.parsedCollection)
+      throw new Error("No Postman collection loaded. Call loadPostmanCollection() first.");
+    const n = this.parsedCollection.endpoints.find((i) => i.name === e);
+    if (!n)
+      throw new Error(`Endpoint "${e}" not found in collection.`);
+    const s = {
+      ...this.parsedCollection.variables,
+      ...t
+    }, a = await U({ endpoint: n, variables: s });
+    if (!a.success)
+      throw new Error(`API request failed: ${a.error}`);
+    const o = ue(a), r = N(o);
+    return { data: o, schema: r };
+  }
+  /**
+   * Query API data with natural language
+   */
+  async queryAPI(e) {
+    if (!this.qaEngine)
+      throw new Error("Q&A engine not initialized. Provide qaConfig in constructor or call initializeQA().");
+    const t = Date.now(), { data: n, schema: s } = await this.fetchDataFromAPI(
+      e.dataSource.endpoint || "",
+      e.variables
+    ), a = {
+      question: e.question,
+      schema: s,
+      data: n
+    }, o = await this.qaEngine.answerQuestion(a), r = Date.now() - t;
+    return {
+      answer: o.answer,
+      apiResponse: n,
+      endpoint: e.dataSource.endpoint,
+      executionTime: r
+    };
+  }
+  /**
+   * List available endpoints from loaded collection
+   */
+  listEndpoints() {
+    return this.parsedCollection ? this.parsedCollection.endpoints.map((e) => ({
+      name: e.name,
+      method: e.method,
+      description: e.description
+    })) : [];
   }
-  return r;
-}
-function F(c, s, e = 0.5) {
-  const n = [], t = 1.5 + (1 - e) * 1.5;
-  return s.forEach((i) => {
-    const r = c.map((m, g) => ({ value: Number(m[i]), idx: g })).filter((m) => !isNaN(m.value));
-    if (r.length === 0) return;
-    const l = [...r].sort((m, g) => m.value - g.value), o = l[Math.floor(l.length * 0.25)].value, p = l[Math.floor(l.length * 0.75)].value, h = p - o, u = o - t * h, d = p + t * h;
-    r.forEach(({ value: m, idx: g }) => {
-      if (m < u || m > d) {
-        const v = n.find((a) => a.rowIndex === g), S = m < u ? `${i}: ${m.toFixed(2)} < ${u.toFixed(2)}` : `${i}: ${m.toFixed(2)} > ${d.toFixed(2)}`;
-        v ? (v.reasons.push(S), v.affectedColumns.push(i), v.score = Math.min(1, v.score + 0.2)) : n.push({
-          rowIndex: g,
-          row: c[g],
-          score: 0.7,
-          reasons: [S],
-          affectedColumns: [i]
-        });
-      }
-    });
-  }), n.sort((i, r) => r.score - i.score);
 }
-function E(c) {
-  const s = new N(c.config), e = M(!1), n = M(null), t = M(null), i = c.data || M([]), r = c.schema || M(null), l = c.useLocalFallback !== !1;
-  async function o(a, f) {
-    e.value = !0, n.value = null;
+function Ye(c) {
+  const e = new de(c.config, c.qaConfig), t = E(!1), n = E(null), s = E(null), a = c.data || E([]), o = c.schema || E(null), r = E([]), i = E([]), l = E(null), g = c.maxQuestionHistory || 50, p = c.useLocalFallback !== !1;
+  async function d(u, w) {
+    t.value = !0, n.value = null;
     try {
-      const y = {
-        type: a,
-        data: i.value,
-        schema: r.value || void 0,
-        options: f
-      }, w = await s.analyze(y);
-      return t.value = w, w;
-    } catch (y) {
-      if (n.value = y instanceof Error ? y : new Error("Analysis failed"), l)
-        return p(a, f);
+      const b = {
+        type: u,
+        data: a.value,
+        schema: o.value || void 0,
+        options: w
+      }, k = await e.analyze(b);
+      return s.value = k, k;
+    } catch (b) {
+      if (n.value = b instanceof Error ? b : new Error("Analysis failed"), p)
+        return y(u, w);
       throw n.value;
     } finally {
-      e.value = !1;
+      t.value = !1;
     }
   }
-  function p(a, f) {
-    const y = r.value || T(i.value);
-    switch (a) {
+  function y(u, w) {
+    const b = o.value || N(a.value);
+    switch (u) {
       case "descriptive_stats": {
-        const w = y.columns.map(
-          (b) => A(i.value, b.name, b.type)
+        const k = b.columns.map(
+          (x) => B(a.value, x.name, x.type)
         );
         return {
-          type: a,
+          type: u,
           timestamp: /* @__PURE__ */ new Date(),
-          descriptiveStats: w,
-          summary: `Calculated statistics for ${w.length} columns`,
+          descriptiveStats: k,
+          summary: `Calculated statistics for ${k.length} columns`,
           insights: [],
           confidence: 0.9
         };
       }
       case "anomaly_detection": {
-        const w = y.columns.filter((C) => C.type === "number").map((C) => C.name), b = F(
-          i.value,
-          w,
-          f == null ? void 0 : f.sensitivity
+        const k = b.columns.filter((q) => q.type === "number").map((q) => q.name), x = ae(
+          a.value,
+          k,
+          w == null ? void 0 : w.sensitivity
         );
         return {
-          type: a,
+          type: u,
           timestamp: /* @__PURE__ */ new Date(),
-          anomalies: b,
-          summary: `Found ${b.length} anomalies`,
-          insights: b.slice(0, 3).map((C) => C.reasons[0]),
+          anomalies: x,
+          summary: `Found ${x.length} anomalies`,
+          insights: x.slice(0, 3).map((q) => q.reasons[0]),
           confidence: 0.8
         };
       }
       default:
-        throw new Error(`Local analysis not supported for type: ${a}`);
+        throw new Error(`Local analysis not supported for type: ${u}`);
     }
   }
-  async function h() {
-    return (await o("descriptive_stats")).descriptiveStats || [];
+  async function v() {
+    return (await d("descriptive_stats")).descriptiveStats || [];
+  }
+  async function $(u, w) {
+    return (await d("anomaly_detection", { sensitivity: w, features: u })).anomalies || [];
+  }
+  async function C(u, w = 3) {
+    return d("clustering", { features: u, numClusters: w });
   }
-  async function u(a, f) {
-    return (await o("anomaly_detection", { sensitivity: f, features: a })).anomalies || [];
+  async function D(u, w) {
+    return d("prediction", { targetColumn: u, ...w });
+  }
+  function _(u) {
+    e.updateConfig(u);
+  }
+  function j(u, w = !0) {
+    a.value = u, w && (o.value = N(u));
+  }
+  function T() {
+    t.value = !1, n.value = null, s.value = null, r.value = [], i.value = [], l.value = null;
+  }
+  async function M(u, w) {
+    t.value = !0, n.value = null;
+    try {
+      const b = o.value || N(a.value), k = {
+        question: u,
+        schema: b,
+        data: a.value,
+        sampleSize: 100,
+        includeAggregates: !0,
+        ...w
+      }, q = (await e.askQuestion(k)).answer, X = {
+        id: q.questionId,
+        text: u,
+        timestamp: /* @__PURE__ */ new Date(),
+        context: {
+          tableSchema: b,
+          rowCount: a.value.length
+        }
+      };
+      return r.value.push(X), i.value.push(q), l.value = q, r.value.length > g && (r.value.shift(), i.value.shift()), q;
+    } catch (b) {
+      throw n.value = b instanceof Error ? b : new Error("Q&A failed"), n.value;
+    } finally {
+      t.value = !1;
+    }
   }
-  async function d(a, f = 3) {
-    return o("clustering", { features: a, numClusters: f });
+  async function P() {
+    t.value = !0, n.value = null;
+    try {
+      const u = o.value || N(a.value);
+      return await e.generateSummary(a.value, u);
+    } catch (u) {
+      throw n.value = u instanceof Error ? u : new Error("Summary generation failed"), n.value;
+    } finally {
+      t.value = !1;
+    }
   }
-  async function m(a, f) {
-    return o("prediction", { targetColumn: a, ...f });
+  function K() {
+    r.value = [], i.value = [], l.value = null;
   }
-  function g(a) {
-    s.updateConfig(a);
+  function G(u) {
+    const w = e.extractFromDOM(u);
+    return w && (a.value = w.data, o.value = w.schema), w;
   }
-  function v(a, f = !0) {
-    i.value = a, f && (r.value = T(a));
+  function Y(u, w, b) {
+    const k = e.normalizeVueData(u, w, b);
+    a.value = k.data, o.value = k.schema;
   }
-  function S() {
-    e.value = !1, n.value = null, t.value = null;
+  function W(u) {
+    e.initializeQA(u);
   }
   return {
-    client: s,
-    loading: e,
+    client: e,
+    loading: t,
     error: n,
-    lastResult: t,
-    data: i,
-    schema: r,
-    analyze: o,
-    getDescriptiveStats: h,
-    detectAnomalies: u,
-    performClustering: d,
-    predict: m,
-    updateConfig: g,
-    setData: v,
-    reset: S
+    lastResult: s,
+    data: a,
+    schema: o,
+    questionHistory: r,
+    answerHistory: i,
+    lastAnswer: l,
+    analyze: d,
+    getDescriptiveStats: v,
+    detectAnomalies: $,
+    performClustering: C,
+    predict: D,
+    askQuestion: M,
+    generateSummary: P,
+    clearHistory: K,
+    extractFromDOM: G,
+    loadFromVueGrid: Y,
+    updateConfig: _,
+    initializeQA: W,
+    setData: j,
+    reset: T
   };
 }
+const me = { class: "ti-question-input" }, pe = { class: "ti-input-wrapper" }, he = ["placeholder", "disabled", "onKeydown"], fe = ["disabled"], ge = { key: 0 }, we = {
+  key: 1,
+  class: "ti-loading"
+}, ye = {
+  key: 0,
+  class: "ti-hint"
+}, ve = /* @__PURE__ */ z({
+  __name: "QuestionInput",
+  props: {
+    placeholder: { default: "Ask a question about this data..." },
+    submitLabel: { default: "Ask" },
+    loadingLabel: { default: "Processing..." },
+    hint: { default: "Press Enter to submit, Shift+Enter for new line" },
+    showHint: { type: Boolean, default: !0 },
+    disabled: { type: Boolean, default: !1 },
+    loading: { type: Boolean, default: !1 }
+  },
+  emits: ["submit"],
+  setup(c, { emit: e }) {
+    const t = c, n = e, s = E("");
+    function a() {
+      s.value.trim() && !t.disabled && !t.loading && (n("submit", s.value.trim()), s.value = "");
+    }
+    function o(r) {
+    }
+    return (r, i) => (f(), h("div", me, [
+      m("div", pe, [
+        Z(m("textarea", {
+          "onUpdate:modelValue": i[0] || (i[0] = (l) => s.value = l),
+          placeholder: r.placeholder,
+          disabled: r.disabled,
+          class: "ti-textarea",
+          rows: "2",
+          onKeydown: [
+            V(R(a, ["exact", "prevent"]), ["enter"]),
+            V(R(o, ["shift"]), ["enter"])
+          ]
+        }, null, 40, he), [
+          [ee, s.value]
+        ]),
+        m("button", {
+          disabled: r.disabled || !s.value.trim(),
+          class: "ti-submit-btn",
+          onClick: a
+        }, [
+          r.loading ? (f(), h("span", we, A(r.loadingLabel), 1)) : (f(), h("span", ge, A(r.submitLabel), 1))
+        ], 8, fe)
+      ]),
+      r.showHint ? (f(), h("div", ye, A(r.hint), 1)) : S("", !0)
+    ]));
+  }
+}), F = (c, e) => {
+  const t = c.__vccOpts || c;
+  for (const [n, s] of e)
+    t[n] = s;
+  return t;
+}, We = /* @__PURE__ */ F(ve, [["__scopeId", "data-v-90db5921"]]), be = { class: "ti-answer-header" }, Ae = { class: "ti-answer-icon" }, $e = { key: 0 }, ke = { key: 1 }, Ce = { class: "ti-answer-meta" }, _e = { class: "ti-confidence" }, qe = { class: "ti-timestamp" }, Ee = { class: "ti-answer-text" }, Se = {
+  key: 0,
+  class: "ti-approximate-notice"
+}, De = {
+  key: 1,
+  class: "ti-reason"
+}, Te = {
+  key: 2,
+  class: "ti-supporting-data"
+}, xe = {
+  key: 0,
+  class: "ti-supporting-content"
+}, Ie = {
+  key: 0,
+  class: "ti-aggregates"
+}, Ne = {
+  key: 1,
+  class: "ti-rows"
+}, Pe = { class: "ti-table-wrapper" }, Me = { class: "ti-table" }, Oe = /* @__PURE__ */ z({
+  __name: "AnswerDisplay",
+  props: {
+    answer: {}
+  },
+  setup(c) {
+    const e = E(!1);
+    function t(n) {
+      return new Date(n).toLocaleTimeString();
+    }
+    return (n, s) => (f(), h("div", {
+      class: te(["ti-answer-display", { "ti-cannot-answer": n.answer.cannotAnswer }])
+    }, [
+      m("div", be, [
+        m("div", Ae, [
+          n.answer.cannotAnswer ? (f(), h("span", ke, "⚠️")) : (f(), h("span", $e, "💡"))
+        ]),
+        m("div", Ce, [
+          m("div", _e, " Confidence: " + A(Math.round(n.answer.confidence * 100)) + "% ", 1),
+          m("div", qe, A(t(n.answer.timestamp)), 1)
+        ])
+      ]),
+      m("div", Ee, A(n.answer.text), 1),
+      n.answer.isApproximate ? (f(), h("div", Se, " ℹ️ This answer is based on sampled data and may be approximate. ")) : S("", !0),
+      n.answer.reason && n.answer.cannotAnswer ? (f(), h("div", De, [
+        s[1] || (s[1] = m("strong", null, "Reason:", -1)),
+        ne(" " + A(n.answer.reason), 1)
+      ])) : S("", !0),
+      n.answer.supportingData ? (f(), h("div", Te, [
+        m("button", {
+          class: "ti-toggle-btn",
+          onClick: s[0] || (s[0] = (a) => e.value = !e.value)
+        }, A(e.value ? "▼" : "▶") + " Supporting Data ", 1),
+        e.value ? (f(), h("div", xe, [
+          n.answer.supportingData.aggregates ? (f(), h("div", Ie, [
+            s[2] || (s[2] = m("h4", null, "Aggregates:", -1)),
+            m("pre", null, A(JSON.stringify(n.answer.supportingData.aggregates, null, 2)), 1)
+          ])) : S("", !0),
+          n.answer.supportingData.rows && n.answer.supportingData.rows.length > 0 ? (f(), h("div", Ne, [
+            m("h4", null, "Sample Rows (" + A(n.answer.supportingData.rows.length) + "):", 1),
+            m("div", Pe, [
+              m("table", Me, [
+                m("thead", null, [
+                  m("tr", null, [
+                    (f(!0), h(O, null, Q(Object.keys(n.answer.supportingData.rows[0]), (a, o) => (f(), h("th", { key: o }, A(a), 1))), 128))
+                  ])
+                ]),
+                m("tbody", null, [
+                  (f(!0), h(O, null, Q(n.answer.supportingData.rows.slice(0, 5), (a, o) => (f(), h("tr", { key: o }, [
+                    (f(!0), h(O, null, Q(Object.keys(a), (r, i) => (f(), h("td", { key: i }, A(a[r]), 1))), 128))
+                  ]))), 128))
+                ])
+              ])
+            ])
+          ])) : S("", !0)
+        ])) : S("", !0)
+      ])) : S("", !0)
+    ], 2));
+  }
+}), Xe = /* @__PURE__ */ F(Oe, [["__scopeId", "data-v-d1aaae1d"]]), Qe = { class: "ti-question-history" }, je = { class: "ti-history-header" }, ze = {
+  key: 0,
+  class: "ti-empty-state"
+}, Fe = {
+  key: 1,
+  class: "ti-history-list"
+}, Ve = ["onClick"], Re = { class: "ti-question-header" }, He = { class: "ti-question-number" }, Le = { class: "ti-question-time" }, Be = { class: "ti-question-text" }, Je = {
+  key: 0,
+  class: "ti-question-context"
+}, Ue = /* @__PURE__ */ z({
+  __name: "QuestionHistory",
+  props: {
+    questions: {}
+  },
+  emits: ["clear", "select"],
+  setup(c, { emit: e }) {
+    const t = c, n = se(() => [...t.questions].reverse());
+    function s(a) {
+      const o = new Date(a), i = (/* @__PURE__ */ new Date()).getTime() - o.getTime(), l = Math.floor(i / 6e4), g = Math.floor(i / 36e5), p = Math.floor(i / 864e5);
+      return l < 1 ? "Just now" : l < 60 ? `${l}m ago` : g < 24 ? `${g}h ago` : `${p}d ago`;
+    }
+    return (a, o) => (f(), h("div", Qe, [
+      m("div", je, [
+        o[1] || (o[1] = m("h3", null, "Question History", -1)),
+        a.questions.length > 0 ? (f(), h("button", {
+          key: 0,
+          class: "ti-clear-btn",
+          onClick: o[0] || (o[0] = (r) => a.$emit("clear"))
+        }, " Clear History ")) : S("", !0)
+      ]),
+      a.questions.length === 0 ? (f(), h("div", ze, o[2] || (o[2] = [
+        m("div", { class: "ti-empty-icon" }, "💬", -1),
+        m("p", null, "No questions asked yet", -1),
+        m("p", { class: "ti-empty-hint" }, "Ask a question about your data to get started", -1)
+      ]))) : (f(), h("div", Fe, [
+        (f(!0), h(O, null, Q(n.value, (r, i) => (f(), h("div", {
+          key: r.id,
+          class: "ti-history-item",
+          onClick: (l) => a.$emit("select", r)
+        }, [
+          m("div", Re, [
+            m("span", He, "#" + A(a.questions.length - i), 1),
+            m("span", Le, A(s(r.timestamp)), 1)
+          ]),
+          m("div", Be, A(r.text), 1),
+          r.context ? (f(), h("div", Je, A(r.context.rowCount) + " rows ", 1)) : S("", !0)
+        ], 8, Ve))), 128))
+      ]))
+    ]));
+  }
+}), Ze = /* @__PURE__ */ F(Ue, [["__scopeId", "data-v-c66393d9"]]);
 export {
-  N as TabularIntelligence,
-  A as calculateStats,
-  F as detectAnomalies,
-  $ as inferColumnType,
-  T as inferSchema,
-  E as useTabularIntelligence
+  Xe as AnswerDisplay,
+  H as QAEngine,
+  Ze as QuestionHistory,
+  We as QuestionInput,
+  de as TabularIntelligence,
+  B as calculateStats,
+  ue as convertToTabular,
+  ae as detectAnomalies,
+  U as executeAPIRequest,
+  Ge as executeMultipleRequests,
+  re as extractFromDOM,
+  L as inferColumnType,
+  N as inferSchema,
+  oe as normalizeVueData,
+  ce as parsePostmanCollection,
+  I as replaceVariables,
+  Ye as useTabularIntelligence
 };
 //# sourceMappingURL=index.mjs.map