@deepagents/text2sql 0.37.1 → 0.38.1

package/dist/lib/adapters/sqlite/index.js

@@ -148,13 +148,14 @@ function relationship(input) {
 }
 
 // packages/text2sql/src/lib/adapters/groundings/context.ts
-function createGroundingContext() {
+function createGroundingContext(options = {}) {
   return {
     tables: [],
     views: [],
     relationships: [],
     info: void 0,
-    cache: /* @__PURE__ */ new Map()
+    cache: /* @__PURE__ */ new Map(),
+    onProgress: options.onProgress
   };
 }
 
@@ -300,7 +301,24 @@ var Adapter = class {
   async introspect(ctx = createGroundingContext()) {
     for (const fn of this.grounding) {
       const grounding = fn(this);
-      await grounding.execute(ctx);
+      if (grounding.phase) {
+        ctx.onProgress?.({
+          type: "phase:start",
+          phase: grounding.phase,
+          message: `Starting ${grounding.name} introspection...`
+        });
+      }
+      try {
+        await grounding.execute(ctx);
+      } finally {
+        if (grounding.phase) {
+          ctx.onProgress?.({
+            type: "phase:end",
+            phase: grounding.phase,
+            message: `Finished ${grounding.name} introspection.`
+          });
+        }
+      }
     }
     return this.#toSchemaFragments(ctx);
   }
@@ -506,26 +524,33 @@ var Adapter = class {
   async #checkScope(sql, allowedEntities) {
     const dialect = this.formatterLanguage;
     const scopeDialects = {
-      sqlite: "mysql",
-      postgresql: "postgresql",
-      bigquery: "bigquery",
-      transactsql: "transactsql",
-      mysql: "mysql"
+      sqlite: ["sqlite", "mysql"],
+      postgresql: ["postgresql"],
+      bigquery: ["bigquery"],
+      transactsql: ["transactsql"],
+      mysql: ["mysql"]
     };
-    const scopeDialect = scopeDialects[dialect];
-    if (!scopeDialect) {
+    const candidates = scopeDialects[dialect];
+    if (!candidates) {
       throw new TypeError(
         `No scope dialect mapping for formatter language "${dialect}". Add it to the scopeDialects map in Adapter.#checkScope.`
       );
     }
-    let references;
-    try {
-      references = extractBaseEntityReferences(sql, scopeDialect);
-    } catch (error) {
+    let references = null;
+    let lastError;
+    for (const candidate of candidates) {
+      try {
+        references = extractBaseEntityReferences(sql, candidate);
+        break;
+      } catch (error) {
+        lastError = error;
+      }
+    }
+    if (references === null) {
       return buildScopeParseErrorPayload(
         sql,
         dialect,
-        error
+        lastError
       );
     }
     if (references.length === 0) return null;
@@ -648,15 +673,17 @@ var AbstractGrounding = class {
    * Grounding identifier for debugging/logging.
    */
   name;
-  constructor(name) {
+  phase;
+  constructor(name, phase) {
     this.name = name;
+    this.phase = phase;
   }
 };
 
 // packages/text2sql/src/lib/adapters/groundings/column-stats.grounding.ts
 var ColumnStatsGrounding = class extends AbstractGrounding {
   constructor(config = {}) {
-    super("columnStats");
+    super("columnStats", "column_stats");
   }
   /**
    * Execute the grounding process.
@@ -664,7 +691,17 @@ var ColumnStatsGrounding = class extends AbstractGrounding {
    */
   async execute(ctx) {
     const allContainers = [...ctx.tables, ...ctx.views];
-    for (const container of allContainers) {
+    const total = allContainers.length;
+    for (let i = 0; i < allContainers.length; i++) {
+      const container = allContainers[i];
+      ctx.onProgress?.({
+        type: "phase:progress",
+        phase: "column_stats",
+        table: container.name,
+        message: `Collecting stats for ${container.name}...`,
+        current: i + 1,
+        total
+      });
       for (const column2 of container.columns) {
         try {
           const stats = await this.collectStats(container.name, column2);
@@ -689,7 +726,7 @@ var ColumnValuesGrounding = class extends AbstractGrounding {
   lowCardinalityLimit;
   maxValueLength;
   constructor(config = {}) {
-    super("columnValues");
+    super("columnValues", "column_values");
     this.lowCardinalityLimit = config.lowCardinalityLimit ?? 20;
     this.maxValueLength = config.maxValueLength ?? 100;
   }
@@ -772,7 +809,17 @@ var ColumnValuesGrounding = class extends AbstractGrounding {
    */
   async execute(ctx) {
     const allContainers = [...ctx.tables, ...ctx.views];
-    for (const container of allContainers) {
+    const total = allContainers.length;
+    for (let i = 0; i < allContainers.length; i++) {
+      const container = allContainers[i];
+      ctx.onProgress?.({
+        type: "phase:progress",
+        phase: "column_values",
+        table: container.name,
+        message: `Collecting column values for ${container.name}...`,
+        current: i + 1,
+        total
+      });
       const table2 = this.getTable(ctx, container.name);
       for (const column2 of container.columns) {
         try {
@@ -826,14 +873,24 @@ var ColumnValuesGrounding = class extends AbstractGrounding {
 // packages/text2sql/src/lib/adapters/groundings/constraint.grounding.ts
 var ConstraintGrounding = class extends AbstractGrounding {
   constructor(config = {}) {
-    super("constraint");
+    super("constraint", "constraints");
   }
   /**
    * Execute the grounding process.
    * Annotates tables in ctx.tables with their constraints.
    */
   async execute(ctx) {
-    for (const table2 of ctx.tables) {
+    const total = ctx.tables.length;
+    for (let i = 0; i < ctx.tables.length; i++) {
+      const table2 = ctx.tables[i];
+      ctx.onProgress?.({
+        type: "phase:progress",
+        phase: "constraints",
+        table: table2.name,
+        message: `Loading constraints for ${table2.name}...`,
+        current: i + 1,
+        total
+      });
       try {
         table2.constraints = await this.getConstraints(table2.name);
       } catch (error) {
@@ -846,14 +903,24 @@ var ConstraintGrounding = class extends AbstractGrounding {
 // packages/text2sql/src/lib/adapters/groundings/indexes.grounding.ts
 var IndexesGrounding = class extends AbstractGrounding {
   constructor(config = {}) {
-    super("index");
+    super("index", "indexes");
   }
   /**
    * Execute the grounding process.
    * Annotates tables in ctx.tables with their indexes and marks indexed columns.
    */
   async execute(ctx) {
-    for (const table2 of ctx.tables) {
+    const total = ctx.tables.length;
+    for (let i = 0; i < ctx.tables.length; i++) {
+      const table2 = ctx.tables[i];
+      ctx.onProgress?.({
+        type: "phase:progress",
+        phase: "indexes",
+        table: table2.name,
+        message: `Loading indexes for ${table2.name}...`,
+        current: i + 1,
+        total
+      });
       table2.indexes = await this.getIndexes(table2.name);
       for (const index2 of table2.indexes ?? []) {
         for (const colName of index2.columns) {
@@ -870,7 +937,7 @@ var IndexesGrounding = class extends AbstractGrounding {
 // packages/text2sql/src/lib/adapters/groundings/info.grounding.ts
 var InfoGrounding = class extends AbstractGrounding {
   constructor(config = {}) {
-    super("dialectInfo");
+    super("dialectInfo", "info");
   }
   /**
    * Execute the grounding process.
@@ -884,14 +951,24 @@ var InfoGrounding = class extends AbstractGrounding {
 // packages/text2sql/src/lib/adapters/groundings/row-count.grounding.ts
 var RowCountGrounding = class extends AbstractGrounding {
   constructor(config = {}) {
-    super("rowCount");
+    super("rowCount", "row_counts");
   }
   /**
    * Execute the grounding process.
    * Annotates tables in ctx.tables with row counts and size hints.
    */
   async execute(ctx) {
-    for (const table2 of ctx.tables) {
+    const total = ctx.tables.length;
+    for (let i = 0; i < ctx.tables.length; i++) {
+      const table2 = ctx.tables[i];
+      ctx.onProgress?.({
+        type: "phase:progress",
+        phase: "row_counts",
+        table: table2.name,
+        message: `Counting rows in ${table2.name}...`,
+        current: i + 1,
+        total
+      });
       const count = await this.getRowCount(table2.name);
       if (count != null) {
         table2.rowCount = count;
@@ -918,7 +995,7 @@ var TableGrounding = class extends AbstractGrounding {
   #forward;
   #backward;
   constructor(config = {}) {
-    super("table");
+    super("table", "tables");
     this.#filter = config.filter;
     this.#columns = config.columns;
     this.#forward = config.forward;
@@ -934,9 +1011,17 @@ var TableGrounding = class extends AbstractGrounding {
     const backward = this.#backward;
     if (!forward && !backward) {
       const tables3 = await Promise.all(
-        seedTables.map(
-          async (name) => applyColumnFilter(await this.getTable(name), this.#columns)
-        )
+        seedTables.map(async (name, index2) => {
+          ctx.onProgress?.({
+            type: "phase:progress",
+            phase: "tables",
+            table: name,
+            message: `Loading table ${name}...`,
+            current: index2 + 1,
+            total: seedTables.length
+          });
+          return applyColumnFilter(await this.getTable(name), this.#columns);
+        })
       );
       ctx.tables.push(...tables3);
       return;
@@ -948,6 +1033,7 @@ var TableGrounding = class extends AbstractGrounding {
     const backwardQueue = [];
     const forwardVisited = /* @__PURE__ */ new Set();
     const backwardVisited = /* @__PURE__ */ new Set();
+    let loadedCount = 0;
     for (const name of seedTables) {
       if (forward) forwardQueue.push({ name, depth: 0 });
       if (backward) backwardQueue.push({ name, depth: 0 });
@@ -960,6 +1046,14 @@ var TableGrounding = class extends AbstractGrounding {
       if (forwardVisited.has(name)) continue;
       forwardVisited.add(name);
       if (!tables2[name]) {
+        loadedCount++;
+        ctx.onProgress?.({
+          type: "phase:progress",
+          phase: "tables",
+          table: name,
+          message: `Loading table ${name}...`,
+          current: loadedCount
+        });
         tables2[name] = applyColumnFilter(
           await this.getTable(name),
           this.#columns
@@ -984,6 +1078,14 @@ var TableGrounding = class extends AbstractGrounding {
       if (backwardVisited.has(name)) continue;
       backwardVisited.add(name);
       if (!tables2[name]) {
+        loadedCount++;
+        ctx.onProgress?.({
+          type: "phase:progress",
+          phase: "tables",
+          table: name,
+          message: `Loading table ${name}...`,
+          current: loadedCount
+        });
         tables2[name] = applyColumnFilter(
           await this.getTable(name),
           this.#columns
@@ -1544,7 +1646,7 @@ var ViewGrounding = class extends AbstractGrounding {
   #columns;
   includeDefinition;
   constructor(config = {}) {
-    super("view");
+    super("view", "views");
     this.#filter = config.filter;
     this.#columns = config.columns;
     this.includeDefinition = config.includeDefinition ?? true;
@@ -1556,9 +1658,17 @@ var ViewGrounding = class extends AbstractGrounding {
   async execute(ctx) {
     const viewNames = await this.applyFilter();
     const views2 = await Promise.all(
-      viewNames.map(
-        async (name) => applyColumnFilter(await this.getView(name), this.#columns)
-      )
+      viewNames.map(async (name, index2) => {
+        ctx.onProgress?.({
+          type: "phase:progress",
+          phase: "views",
+          table: name,
+          message: `Loading view ${name}...`,
+          current: index2 + 1,
+          total: viewNames.length
+        });
+        return applyColumnFilter(await this.getView(name), this.#columns);
+      })
     );
     ctx.views.push(...views2);
   }