@aivue/tabular-intelligence 1.0.0 → 1.1.0

package/dist/index.mjs

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