@botpress/adk 1.7.16 → 1.7.18

package/dist/generators/tests.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tests.d.ts","sourceRoot":"","sources":["../../src/generators/tests.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,oBAAoB,GAAI,aAAa,MAAM,EAAE,SAAS,MAAM,oDAiBrE,CAAA;AAEJ,eAAO,MAAM,kBAAkB,GAAI,KAAK,MAAM,EAAE,SAAS,MAAM;;;;;;;;iBAkBu1v5B,CAAC;uBAA0H,CAAC;;;;;;;;iBAAuU,CAAC;uBAAyH,CAAC;;;;sBAAsM,CAAC;;;;;;;iBAA6S,CAAC;uBAA0H,CAAC;oBAAkC,CAAC;qBAAoC,CAAC;;;;;;;;;;;sBAA2Y,CAAC;;;;;;;iBAA8O,CAAC;uBAA2H,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAr48M,CAAC;uBAA0H,CAAC;;;;;;;;iBAAuU,CAAC;uBAAyH,CAAC;;;;sBAAsM,CAAC;;;;;;;iBAA6S,CAAC;uBAA0H,CAAC;oBAAkC,CAAC;qBAAoC,CAAC;;;;;;;;;;;sBAA2Y,CAAC;;;;;;;iBAA8O,CAAC;uBAA2H,CAAC;;;;;;;;;;;;;;;;;;;;;;EADv+6sB,CAAA"}
+{"version":3,"file":"tests.d.ts","sourceRoot":"","sources":["../../src/generators/tests.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,oBAAoB,GAAI,aAAa,MAAM,EAAE,SAAS,MAAM,oDAiBrE,CAAA;AAEJ,eAAO,MAAM,kBAAkB,GAAI,KAAK,MAAM,EAAE,SAAS,MAAM;;;;;;;;iBAkB+jk6B,CAAC;uBAA0H,CAAC;;;;;;;;iBAAuU,CAAC;uBAAyH,CAAC;;;;sBAAsM,CAAC;;;;;;;iBAA6S,CAAC;uBAA0H,CAAC;oBAAkC,CAAC;qBAAoC,CAAC;;;;;;;;;;;sBAA2Y,CAAC;;;;;;;iBAA8O,CAAC;uBAA2H,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAA35/M,CAAC;uBAA0H,CAAC;;;;;;;;iBAAuU,CAAC;uBAAyH,CAAC;;;;sBAAsM,CAAC;;;;;;;iBAA6S,CAAC;uBAA0H,CAAC;oBAAkC,CAAC;qBAAoC,CAAC;;;;;;;;;;;sBAA2Y,CAAC;;;;;;;iBAA8O,CAAC;uBAA2H,CAAC;;;;;;;;;;;;;;;;;;;;;;EADzrstB,CAAA"}

package/dist/index.js

@@ -654,7 +654,7 @@ var PRETTIER_CONFIG, formatCode = async (code, filepath) => {
 `));
     return code;
   }
-}, ADK_VERSION = "1.7.16", relative2 = (from, to) => {
+}, ADK_VERSION = "1.7.18", relative2 = (from, to) => {
   const fromDir = path10.dirname(from);
   const relative3 = path10.relative(fromDir, to);
   return relative3.startsWith(".") ? relative3 : `./${relative3}`;
@@ -797,7 +797,7 @@ var init_integration_action_types = __esm(() => {
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "@botpress/adk",
-    version: "1.7.16",
+    version: "1.7.18",
     description: "Core ADK library for building AI agents on Botpress",
     type: "module",
     main: "dist/index.js",
@@ -842,9 +842,9 @@ var require_package = __commonJS((exports, module) => {
     },
     dependencies: {
       "@botpress/cli": "^4.23",
-      "@botpress/client": "^1.27.0",
+      "@botpress/client": "^1.27.2",
       "@botpress/cognitive": "^0.2.0",
-      "@botpress/runtime": "^1.7.16",
+      "@botpress/runtime": "^1.7.18",
       "@botpress/sdk": "^4.18.1",
       "@bpinternal/yargs-extra": "^0.0.21",
       "@parcel/watcher": "^2.5.1",
@@ -4829,7 +4829,7 @@ class AgentProjectGenerator {
         deploy: "adk deploy"
       },
       dependencies: {
-        "@botpress/runtime": `^${"1.7.16"}`
+        "@botpress/runtime": `^${"1.7.18"}`
       },
       devDependencies: {
         typescript: "^5.9.3"
@@ -7337,7 +7337,7 @@ async function generateBotProject(options) {
     });
   }
 }
-// src/tables/manager.ts
+// src/tables/table-manager.ts
 import { Client as Client11 } from "@botpress/client";
 import { transforms as transforms4 } from "@botpress/sdk";
 class TableManager {
@@ -7368,6 +7368,233 @@ class TableManager {
       throw new Error(`Operation "${operation}" requires a bot ID. ` + "Please deploy your agent first or create agent.json with botId and workspaceId.");
     }
   }
+  getSchemaType(schema) {
+    if (schema.type) {
+      if (schema.type === "array" && schema.items?.type) {
+        return `array<${schema.items.type}>`;
+      }
+      return schema.type;
+    }
+    if (schema.$ref) {
+      return schema.$ref.split("/").pop() || "unknown";
+    }
+    return "unknown";
+  }
+  calculateRenameScore(oldName, newName, oldSchema, newSchema, oldPosition, newPosition) {
+    let score = 0;
+    if (oldPosition === newPosition) {
+      score += 3;
+    } else if (Math.abs(oldPosition - newPosition) <= 1) {
+      score += 1;
+    }
+    const oldDesc = (oldSchema?.description || "").toLowerCase();
+    const newDesc = (newSchema?.description || "").toLowerCase();
+    if (oldDesc && newDesc && oldDesc === newDesc) {
+      score += 5;
+    } else if (oldDesc && newDesc && oldDesc.length > 5 && newDesc.length > 5) {
+      if (oldDesc.includes(newDesc) || newDesc.includes(oldDesc)) {
+        score += 2;
+      } else {
+        const oldWords = oldDesc.split(/\s+/);
+        const newWords = newDesc.split(/\s+/);
+        const commonWords = oldWords.filter((w) => newWords.includes(w) && w.length > 3);
+        if (commonWords.length >= 2) {
+          score += 1;
+        }
+      }
+    }
+    const oldOptional = oldSchema?.type?.includes("null") || oldSchema?.nullable === true;
+    const newOptional = newSchema?.type?.includes("null") || newSchema?.nullable === true;
+    if (oldOptional === newOptional) {
+      score += 1;
+    }
+    const oldSearchable = oldSchema?.["x-zui"]?.searchable;
+    const newSearchable = newSchema?.["x-zui"]?.searchable;
+    if (oldSearchable === newSearchable) {
+      score += 1;
+    }
+    return score;
+  }
+  cleanSchemaForComparison(schema) {
+    if (!schema || typeof schema !== "object") {
+      return schema;
+    }
+    const cleaned = Array.isArray(schema) ? [...schema] : { ...schema };
+    if (cleaned["x-zui"]) {
+      const xZui = { ...cleaned["x-zui"] };
+      delete xZui.index;
+      if (Object.keys(xZui).length === 0) {
+        delete cleaned["x-zui"];
+      } else {
+        cleaned["x-zui"] = xZui;
+      }
+    }
+    if (cleaned.properties) {
+      const cleanedProps = {};
+      for (const [key, value] of Object.entries(cleaned.properties)) {
+        cleanedProps[key] = this.cleanSchemaForComparison(value);
+      }
+      cleaned.properties = cleanedProps;
+    }
+    if (cleaned.items) {
+      cleaned.items = this.cleanSchemaForComparison(cleaned.items);
+    }
+    delete cleaned.additionalProperties;
+    return cleaned;
+  }
+  analyzeColumnChanges(local, remote) {
+    const differences = [];
+    const columnChanges = [];
+    if (!local || !remote) {
+      return { differences, columnChanges };
+    }
+    const cleanedLocal = this.cleanSchemaForComparison(local);
+    const cleanedRemote = this.cleanSchemaForComparison(remote);
+    const localProps = cleanedLocal.properties || {};
+    const remoteProps = cleanedRemote.properties || {};
+    const localKeys = Object.keys(localProps);
+    const remoteKeys = Object.keys(remoteProps);
+    const addedKeys = localKeys.filter((k) => !remoteKeys.includes(k));
+    const removedKeys = remoteKeys.filter((k) => !localKeys.includes(k));
+    const commonKeys = localKeys.filter((k) => remoteKeys.includes(k));
+    const addedByType = new Map;
+    const removedByType = new Map;
+    for (const key of addedKeys) {
+      const localType = this.getSchemaType(localProps[key]);
+      if (!addedByType.has(localType)) {
+        addedByType.set(localType, []);
+      }
+      addedByType.get(localType).push(key);
+    }
+    for (const key of removedKeys) {
+      const remoteType = this.getSchemaType(remoteProps[key]);
+      if (!removedByType.has(remoteType)) {
+        removedByType.set(remoteType, []);
+      }
+      removedByType.get(remoteType).push(key);
+    }
+    const renamedColumns = new Set;
+    for (const [type, removedCols] of removedByType.entries()) {
+      const addedCols = addedByType.get(type) || [];
+      if (removedCols.length === 0 || addedCols.length === 0) {
+        continue;
+      }
+      const matches = [];
+      for (const removed of removedCols) {
+        for (const added of addedCols) {
+          const score = this.calculateRenameScore(removed, added, remoteProps[removed], localProps[added], remoteKeys.indexOf(removed), localKeys.indexOf(added));
+          if (score > 0) {
+            matches.push({ removed, added, score });
+          }
+        }
+      }
+      matches.sort((a, b) => b.score - a.score);
+      const usedRemoved = new Set;
+      const usedAdded = new Set;
+      for (const match of matches) {
+        if (usedRemoved.has(match.removed) || usedAdded.has(match.added)) {
+          continue;
+        }
+        if (match.score >= 2) {
+          columnChanges.push({
+            type: "rename",
+            columnName: match.added,
+            oldColumnName: match.removed,
+            oldType: type,
+            newType: type,
+            details: `Column "${match.removed}" → "${match.added}"`
+          });
+          differences.push(`↔️ Renamed column "${match.removed}" → "${match.added}" (${type})`);
+          renamedColumns.add(match.removed);
+          renamedColumns.add(match.added);
+          usedRemoved.add(match.removed);
+          usedAdded.add(match.added);
+        }
+      }
+    }
+    const localRequired = cleanedLocal.required || [];
+    const remoteRequired = cleanedRemote.required || [];
+    for (const key of addedKeys) {
+      if (!renamedColumns.has(key)) {
+        const localType = this.getSchemaType(localProps[key]);
+        const isRequired = localRequired.includes(key);
+        columnChanges.push({
+          type: "add",
+          columnName: key,
+          newType: localType
+        });
+        const requiredSuffix = isRequired ? " - required" : "";
+        differences.push(`➕ Added column "${key}" (${localType})${requiredSuffix}`);
+      }
+    }
+    for (const key of removedKeys) {
+      if (!renamedColumns.has(key)) {
+        const remoteType = this.getSchemaType(remoteProps[key]);
+        const wasRequired = remoteRequired.includes(key);
+        columnChanges.push({
+          type: "remove",
+          columnName: key,
+          oldType: remoteType
+        });
+        const requiredSuffix = wasRequired ? " - was required" : "";
+        differences.push(`➖ Removed column "${key}" (${remoteType})${requiredSuffix}`);
+      }
+    }
+    for (const key of commonKeys) {
+      const localCol = localProps[key];
+      const remoteCol = remoteProps[key];
+      const localType = this.getSchemaType(localCol);
+      const remoteType = this.getSchemaType(remoteCol);
+      if (localType !== remoteType) {
+        columnChanges.push({
+          type: "modify",
+          columnName: key,
+          oldType: remoteType,
+          newType: localType,
+          details: `Type changed from ${remoteType} to ${localType}`
+        });
+        differences.push(`\uD83D\uDD00 Column "${key}": type changed from ${remoteType} to ${localType}`);
+      }
+      const localSearchable = localCol?.["x-zui"]?.searchable;
+      const remoteSearchable = remoteCol?.["x-zui"]?.searchable;
+      if (localSearchable !== remoteSearchable) {
+        differences.push(`\uD83D\uDD0D Column "${key}": searchable ${remoteSearchable ? "disabled" : "enabled"} (was ${remoteSearchable ? "enabled" : "disabled"})`);
+      }
+      const localRequired2 = cleanedLocal.required?.includes(key) || false;
+      const remoteRequired2 = cleanedRemote.required?.includes(key) || false;
+      if (localRequired2 !== remoteRequired2) {
+        differences.push(`${localRequired2 ? "\uD83D\uDD12" : "\uD83D\uDD13"} Column "${key}": ${localRequired2 ? "now required" : "now optional"}`);
+      }
+      const cleanedLocalCol = this.cleanSchemaForComparison(localCol);
+      const cleanedRemoteCol = this.cleanSchemaForComparison(remoteCol);
+      if (JSON.stringify(cleanedLocalCol) !== JSON.stringify(cleanedRemoteCol) && localType === remoteType) {
+        const localDesc = localCol?.description;
+        const remoteDesc = remoteCol?.description;
+        if (localDesc !== remoteDesc) {
+          differences.push(`\uD83D\uDCAC Column "${key}": description updated`);
+        }
+      }
+    }
+    return { differences, columnChanges };
+  }
+  createSchemaForUpdate(localSchema, columnChanges) {
+    const updatedSchema = JSON.parse(JSON.stringify(localSchema));
+    if (!updatedSchema.properties) {
+      updatedSchema.properties = {};
+    }
+    if (!updatedSchema.required) {
+      updatedSchema.required = [];
+    }
+    for (const change of columnChanges) {
+      if (change.type === "remove") {
+        updatedSchema.properties[change.columnName] = { type: "null" };
+        if (updatedSchema.required && updatedSchema.required.includes(change.columnName)) {
+          updatedSchema.required = updatedSchema.required.filter((req) => req !== change.columnName);
+        }
+      }
+    }
+    return updatedSchema;
+  }
   async getLocalTables() {
     const tables = [];
     for (const tableRef of this.project.tables) {
@@ -7377,7 +7604,7 @@ class TableManager {
           factor: tableRef.definition.factor,
           schema: tableRef.definition.schema
         });
-      } catch (error) {}
+      } catch {}
     }
     return tables;
   }
@@ -7386,13 +7613,25 @@ class TableManager {
     const client = await this.getClient();
     try {
       const response = await client.listTables({});
-      return response.tables.map((table) => ({
-        id: table.id,
-        name: table.name,
-        createdAt: table.createdAt || new Date().toISOString(),
-        updatedAt: table.updatedAt || new Date().toISOString(),
-        schema: table.schema
+      const tablesWithCounts = await Promise.all(response.tables.map(async (table) => {
+        let rowCount = 0;
+        try {
+          const tableInfo = await client.getTable({ table: table.name });
+          rowCount = tableInfo.rows || 0;
+        } catch (error) {
+          console.warn(`Failed to get row count for table ${table.name}:`, error);
+        }
+        return {
+          id: table.id,
+          name: table.name,
+          createdAt: table.createdAt || new Date().toISOString(),
+          updatedAt: table.updatedAt || new Date().toISOString(),
+          factor: table.factor || 1,
+          schema: table.schema,
+          rowCount
+        };
       }));
+      return tablesWithCounts;
     } catch (error) {
       console.error("Failed to list remote tables:", error);
       return [];
@@ -7413,14 +7652,34 @@ class TableManager {
         });
       } else {
         try {
-          const localSchema = transforms4.fromJSONSchema(local.schema);
-          const remoteSchema = transforms4.fromJSONSchema(remote.schema);
-          if (!localSchema.isEqual(remoteSchema)) {
+          const cleanedLocalSchema = this.cleanSchemaForComparison(local.schema);
+          const cleanedRemoteSchema = this.cleanSchemaForComparison(remote.schema);
+          const { differences, columnChanges } = this.analyzeColumnChanges(local.schema, remote.schema);
+          const factorMatches = (local.factor || 1) === (remote.factor || 1);
+          const localSchema = transforms4.fromJSONSchema(cleanedLocalSchema);
+          const remoteSchema = transforms4.fromJSONSchema(cleanedRemoteSchema);
+          const schemasEqual = localSchema.isEqual(remoteSchema);
+          const hasMetadataChanges = differences.length > 0;
+          if (!schemasEqual || !factorMatches || hasMetadataChanges) {
+            const reasons = [];
+            if (differences.length > 0) {
+              reasons.push("schema changes detected");
+            } else if (!schemasEqual) {
+              reasons.push("schema metadata changed");
+            }
+            if (!factorMatches) {
+              differences.push(`⚡ Factor: ${remote.factor || 1} → ${local.factor || 1}`);
+              reasons.push("factor changed");
+            }
+            const schemaForUpdate = this.createSchemaForUpdate(local.schema, columnChanges);
             items.push({
               operation: "update" /* Update */,
               localTable: local,
               remoteTable: remote,
-              reason: "Table schema has changed"
+              reason: `Table ${reasons.join(" and ")}`,
+              differences: differences.length > 0 ? differences : undefined,
+              columnChanges: columnChanges.length > 0 ? columnChanges : undefined,
+              schemaForUpdate
             });
           } else {
             items.push({
@@ -7430,7 +7689,7 @@ class TableManager {
               reason: "Table schema is up to date"
             });
           }
-        } catch (error) {
+        } catch {
           items.push({
             operation: "update" /* Update */,
             localTable: local,
@@ -7498,9 +7757,27 @@ class TableManager {
             break;
           case "update" /* Update */:
             if (item.localTable && item.remoteTable) {
+              if (item.columnChanges) {
+                const renames = item.columnChanges.filter((c) => c.type === "rename");
+                for (const rename of renames) {
+                  if (rename.oldColumnName && rename.columnName) {
+                    await client.renameTableColumn({
+                      table: item.localTable.name,
+                      name: rename.oldColumnName,
+                      newName: rename.columnName
+                    });
+                  }
+                }
+              }
+              let schemaToUse = item.schemaForUpdate || item.localTable.schema;
+              const localFactor = item.localTable.factor || 1;
+              if (!schemaToUse.required) {
+                schemaToUse = { ...schemaToUse, required: [] };
+              }
               await client.updateTable({
                 table: item.localTable.name,
-                schema: item.localTable.schema
+                factor: localFactor,
+                schema: schemaToUse
               });
               success.push(item);
             }
@@ -8093,5 +8370,5 @@ export {
   AgentProject
 };
 
-//# debugId=88DC079EBCAF8D3A64756E2164756E21
+//# debugId=E2B8ECAD0716A8AB64756E2164756E21
 //# sourceMappingURL=index.js.map