@agentforge/tools 0.16.40 → 0.16.42

package/dist/index.js

@@ -6034,156 +6034,7 @@ async function withTransaction(manager, operation, options) {
 // src/data/relational/schema/validation.ts
 var VALID_TABLE_FILTER_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]*(\.[a-zA-Z_][a-zA-Z0-9_]*)?$/;
 
-// src/data/relational/schema/schema-inspector.ts
-var logger13 = createLogger("agentforge:tools:data:relational:schema-inspector");
-var DEFAULT_CACHE_TTL_MS = 6e4;
-var schemaCache = /* @__PURE__ */ new Map();
-var POSTGRES_TABLES_QUERY = `
-SELECT
-  table_schema AS schema_name,
-  table_name
-FROM information_schema.tables
-WHERE table_type = 'BASE TABLE'
-  AND table_schema NOT IN ('pg_catalog', 'information_schema')
-ORDER BY table_schema, table_name
-`;
-var POSTGRES_COLUMNS_QUERY = `
-SELECT
-  table_schema AS schema_name,
-  table_name,
-  column_name,
-  data_type,
-  is_nullable,
-  column_default
-FROM information_schema.columns
-WHERE table_schema NOT IN ('pg_catalog', 'information_schema')
-ORDER BY table_schema, table_name, ordinal_position
-`;
-var POSTGRES_PRIMARY_KEYS_QUERY = `
-SELECT
-  kcu.table_schema AS schema_name,
-  kcu.table_name,
-  kcu.column_name,
-  kcu.ordinal_position AS key_position
-FROM information_schema.table_constraints tc
-JOIN information_schema.key_column_usage kcu
-  ON tc.constraint_name = kcu.constraint_name
- AND tc.table_schema = kcu.table_schema
- AND tc.table_name = kcu.table_name
-WHERE tc.constraint_type = 'PRIMARY KEY'
-ORDER BY kcu.table_schema, kcu.table_name, kcu.ordinal_position
-`;
-var POSTGRES_FOREIGN_KEYS_QUERY = `
-SELECT
-  tc.table_schema AS schema_name,
-  tc.table_name,
-  tc.constraint_name,
-  kcu.column_name,
-  ccu.table_schema AS referenced_schema_name,
-  ccu.table_name AS referenced_table_name,
-  ccu.column_name AS referenced_column_name
-FROM information_schema.table_constraints tc
-JOIN information_schema.key_column_usage kcu
-  ON tc.constraint_name = kcu.constraint_name
- AND tc.table_schema = kcu.table_schema
-JOIN information_schema.constraint_column_usage ccu
-  ON ccu.constraint_name = tc.constraint_name
- AND ccu.table_schema = tc.table_schema
-WHERE tc.constraint_type = 'FOREIGN KEY'
-ORDER BY tc.table_schema, tc.table_name, tc.constraint_name, kcu.ordinal_position
-`;
-var POSTGRES_INDEXES_QUERY = `
-SELECT
-  ns.nspname AS schema_name,
-  tbl.relname AS table_name,
-  idx.relname AS index_name,
-  ix.indisunique AS is_unique,
-  att.attname AS column_name,
-  ord.ordinality AS column_position
-FROM pg_class tbl
-JOIN pg_namespace ns
-  ON ns.oid = tbl.relnamespace
-JOIN pg_index ix
-  ON ix.indrelid = tbl.oid
-JOIN pg_class idx
-  ON idx.oid = ix.indexrelid
-JOIN LATERAL unnest(ix.indkey) WITH ORDINALITY AS ord(attnum, ordinality)
-  ON true
-JOIN pg_attribute att
-  ON att.attrelid = tbl.oid
- AND att.attnum = ord.attnum
-WHERE tbl.relkind = 'r'
-  AND ns.nspname NOT IN ('pg_catalog', 'information_schema')
-  AND ix.indisprimary = false
-ORDER BY ns.nspname, tbl.relname, idx.relname, ord.ordinality
-`;
-var MYSQL_TABLES_QUERY = `
-SELECT
-  table_schema AS schema_name,
-  table_name AS table_name
-FROM information_schema.tables
-WHERE table_type = 'BASE TABLE'
-  AND table_schema = DATABASE()
-ORDER BY table_name
-`;
-var MYSQL_COLUMNS_QUERY = `
-SELECT
-  table_schema AS schema_name,
-  table_name AS table_name,
-  column_name AS column_name,
-  column_type AS data_type,
-  is_nullable AS is_nullable,
-  column_default AS column_default
-FROM information_schema.columns
-WHERE table_schema = DATABASE()
-ORDER BY table_name, ordinal_position
-`;
-var MYSQL_PRIMARY_KEYS_QUERY = `
-SELECT
-  table_schema AS schema_name,
-  table_name AS table_name,
-  column_name AS column_name,
-  ordinal_position AS key_position
-FROM information_schema.key_column_usage
-WHERE table_schema = DATABASE()
-  AND constraint_name = 'PRIMARY'
-ORDER BY table_name, ordinal_position
-`;
-var MYSQL_FOREIGN_KEYS_QUERY = `
-SELECT
-  table_schema AS schema_name,
-  table_name AS table_name,
-  constraint_name AS constraint_name,
-  column_name AS column_name,
-  referenced_table_schema AS referenced_schema_name,
-  referenced_table_name AS referenced_table_name,
-  referenced_column_name AS referenced_column_name
-FROM information_schema.key_column_usage
-WHERE table_schema = DATABASE()
-  AND referenced_table_name IS NOT NULL
-ORDER BY table_name, constraint_name, ordinal_position
-`;
-var MYSQL_INDEXES_QUERY = `
-SELECT
-  table_schema AS schema_name,
-  table_name AS table_name,
-  index_name AS index_name,
-  non_unique AS non_unique,
-  column_name AS column_name,
-  seq_in_index AS seq_in_index
-FROM information_schema.statistics
-WHERE table_schema = DATABASE()
-  AND index_name <> 'PRIMARY'
-ORDER BY table_name, index_name, seq_in_index
-`;
-var SQLITE_TABLES_QUERY = `
-SELECT
-  name AS table_name
-FROM sqlite_master
-WHERE type = 'table'
-  AND name NOT LIKE 'sqlite_%'
-ORDER BY name
-`;
+// src/data/relational/schema/schema-inspector-shared.ts
 function normalizeFilterName(value) {
   return value.trim().toLowerCase();
 }
@@ -6279,14 +6130,391 @@ function escapeSqliteStringLiteral(value) {
 function sortColumnsByPosition(columnsByPosition) {
   return columnsByPosition.sort((a, b) => a.position - b.position).map((entry) => entry.column);
 }
+function createTableMap(refs) {
+  const tableMap2 = /* @__PURE__ */ new Map();
+  for (const ref of refs) {
+    const key = buildTableKey(ref.tableName, ref.schemaName);
+    tableMap2.set(key, {
+      name: ref.tableName,
+      schema: ref.schemaName,
+      columns: [],
+      primaryKey: [],
+      foreignKeys: [],
+      indexes: []
+    });
+  }
+  return tableMap2;
+}
+function getTableFromRow(tableMap2, row, tableField, schemaField) {
+  const tableName = toStringValue(row[tableField]);
+  const schemaName = toOptionalStringValue(row[schemaField]) ;
+  const key = buildTableKey(tableName, schemaName);
+  return tableMap2.get(key);
+}
+function createColumnSchema(row, fields) {
+  return {
+    name: toStringValue(row[fields?.name ?? "column_name"]),
+    type: toStringValue(row[fields?.type ?? "data_type"]),
+    isNullable: toBooleanValue(row[fields?.nullable ?? "is_nullable"]),
+    defaultValue: row[fields?.defaultValue ?? "column_default"] ?? null,
+    isPrimaryKey: fields?.primaryKey ?? false
+  };
+}
+function applyPrimaryKeyColumn(table, columnName) {
+  table.primaryKey.push(columnName);
+  const column = table.columns.find((entry) => entry.name === columnName);
+  if (column) {
+    column.isPrimaryKey = true;
+  }
+}
+function applyIndexRows(tableMap2, rows, tableField, schemaField, config) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const table = getTableFromRow(tableMap2, row, tableField, schemaField);
+    if (!table) {
+      continue;
+    }
+    const indexName = toStringValue(row[config.indexNameField]);
+    if (!indexName) {
+      continue;
+    }
+    const groupKey = `${table.schema ?? ""}.${table.name}.${indexName}`;
+    const entry = grouped.get(groupKey) ?? {
+      table,
+      indexName,
+      isUnique: config.uniqueResolver(row),
+      columnsByPosition: []
+    };
+    entry.columnsByPosition.push({
+      position: toNumberValue(row[config.positionField]),
+      column: toStringValue(row[config.columnField])
+    });
+    grouped.set(groupKey, entry);
+  }
+  for (const entry of grouped.values()) {
+    const index = {
+      name: entry.indexName,
+      isUnique: entry.isUnique,
+      columns: sortColumnsByPosition(entry.columnsByPosition)
+    };
+    entry.table.indexes.push(index);
+  }
+}
+
+// src/data/relational/schema/schema-inspector-mysql.ts
+var MYSQL_TABLES_QUERY = `
+SELECT
+  table_schema AS schema_name,
+  table_name AS table_name
+FROM information_schema.tables
+WHERE table_type = 'BASE TABLE'
+  AND table_schema = DATABASE()
+ORDER BY table_name
+`;
+var MYSQL_COLUMNS_QUERY = `
+SELECT
+  table_schema AS schema_name,
+  table_name AS table_name,
+  column_name AS column_name,
+  column_type AS data_type,
+  is_nullable AS is_nullable,
+  column_default AS column_default
+FROM information_schema.columns
+WHERE table_schema = DATABASE()
+ORDER BY table_name, ordinal_position
+`;
+var MYSQL_PRIMARY_KEYS_QUERY = `
+SELECT
+  table_schema AS schema_name,
+  table_name AS table_name,
+  column_name AS column_name,
+  ordinal_position AS key_position
+FROM information_schema.key_column_usage
+WHERE table_schema = DATABASE()
+  AND constraint_name = 'PRIMARY'
+ORDER BY table_name, ordinal_position
+`;
+var MYSQL_FOREIGN_KEYS_QUERY = `
+SELECT
+  table_schema AS schema_name,
+  table_name AS table_name,
+  constraint_name AS constraint_name,
+  column_name AS column_name,
+  referenced_table_schema AS referenced_schema_name,
+  referenced_table_name AS referenced_table_name,
+  referenced_column_name AS referenced_column_name
+FROM information_schema.key_column_usage
+WHERE table_schema = DATABASE()
+  AND referenced_table_name IS NOT NULL
+ORDER BY table_name, constraint_name, ordinal_position
+`;
+var MYSQL_INDEXES_QUERY = `
+SELECT
+  table_schema AS schema_name,
+  table_name AS table_name,
+  index_name AS index_name,
+  non_unique AS non_unique,
+  column_name AS column_name,
+  seq_in_index AS seq_in_index
+FROM information_schema.statistics
+WHERE table_schema = DATABASE()
+  AND index_name <> 'PRIMARY'
+ORDER BY table_name, index_name, seq_in_index
+`;
+async function inspectMySQL(runQueryRows) {
+  const tableRows = await runQueryRows(MYSQL_TABLES_QUERY);
+  const tableMap2 = createTableMap(
+    tableRows.map((row) => ({
+      schemaName: toOptionalStringValue(row.schema_name),
+      tableName: toStringValue(row.table_name)
+    }))
+  );
+  const columnsRows = await runQueryRows(MYSQL_COLUMNS_QUERY);
+  for (const row of columnsRows) {
+    const table = getTableFromRow(tableMap2, row, "table_name", "schema_name");
+    if (!table) {
+      continue;
+    }
+    table.columns.push(createColumnSchema(row));
+  }
+  const primaryKeyRows = await runQueryRows(MYSQL_PRIMARY_KEYS_QUERY);
+  for (const row of primaryKeyRows) {
+    const table = getTableFromRow(tableMap2, row, "table_name", "schema_name");
+    if (!table) {
+      continue;
+    }
+    applyPrimaryKeyColumn(table, toStringValue(row.column_name));
+  }
+  const foreignKeyRows = await runQueryRows(MYSQL_FOREIGN_KEYS_QUERY);
+  for (const row of foreignKeyRows) {
+    const table = getTableFromRow(tableMap2, row, "table_name", "schema_name");
+    if (!table) {
+      continue;
+    }
+    const foreignKey = {
+      name: toOptionalStringValue(row.constraint_name),
+      column: toStringValue(row.column_name),
+      referencedSchema: toOptionalStringValue(row.referenced_schema_name),
+      referencedTable: toStringValue(row.referenced_table_name),
+      referencedColumn: toStringValue(row.referenced_column_name)
+    };
+    table.foreignKeys.push(foreignKey);
+  }
+  const indexRows = await runQueryRows(MYSQL_INDEXES_QUERY);
+  applyIndexRows(tableMap2, indexRows, "table_name", "schema_name", {
+    indexNameField: "index_name",
+    columnField: "column_name",
+    positionField: "seq_in_index",
+    uniqueResolver: (row) => !toBooleanValue(row.non_unique)
+  });
+  return Array.from(tableMap2.values());
+}
+
+// src/data/relational/schema/schema-inspector-postgresql.ts
+var POSTGRES_TABLES_QUERY = `
+SELECT
+  table_schema AS schema_name,
+  table_name
+FROM information_schema.tables
+WHERE table_type = 'BASE TABLE'
+  AND table_schema NOT IN ('pg_catalog', 'information_schema')
+ORDER BY table_schema, table_name
+`;
+var POSTGRES_COLUMNS_QUERY = `
+SELECT
+  table_schema AS schema_name,
+  table_name,
+  column_name,
+  data_type,
+  is_nullable,
+  column_default
+FROM information_schema.columns
+WHERE table_schema NOT IN ('pg_catalog', 'information_schema')
+ORDER BY table_schema, table_name, ordinal_position
+`;
+var POSTGRES_PRIMARY_KEYS_QUERY = `
+SELECT
+  kcu.table_schema AS schema_name,
+  kcu.table_name,
+  kcu.column_name,
+  kcu.ordinal_position AS key_position
+FROM information_schema.table_constraints tc
+JOIN information_schema.key_column_usage kcu
+  ON tc.constraint_name = kcu.constraint_name
+ AND tc.table_schema = kcu.table_schema
+ AND tc.table_name = kcu.table_name
+WHERE tc.constraint_type = 'PRIMARY KEY'
+ORDER BY kcu.table_schema, kcu.table_name, kcu.ordinal_position
+`;
+var POSTGRES_FOREIGN_KEYS_QUERY = `
+SELECT
+  tc.table_schema AS schema_name,
+  tc.table_name,
+  tc.constraint_name,
+  kcu.column_name,
+  ccu.table_schema AS referenced_schema_name,
+  ccu.table_name AS referenced_table_name,
+  ccu.column_name AS referenced_column_name
+FROM information_schema.table_constraints tc
+JOIN information_schema.key_column_usage kcu
+  ON tc.constraint_name = kcu.constraint_name
+ AND tc.table_schema = kcu.table_schema
+JOIN information_schema.constraint_column_usage ccu
+  ON ccu.constraint_name = tc.constraint_name
+ AND ccu.table_schema = tc.table_schema
+WHERE tc.constraint_type = 'FOREIGN KEY'
+ORDER BY tc.table_schema, tc.table_name, tc.constraint_name, kcu.ordinal_position
+`;
+var POSTGRES_INDEXES_QUERY = `
+SELECT
+  ns.nspname AS schema_name,
+  tbl.relname AS table_name,
+  idx.relname AS index_name,
+  ix.indisunique AS is_unique,
+  att.attname AS column_name,
+  ord.ordinality AS column_position
+FROM pg_class tbl
+JOIN pg_namespace ns
+  ON ns.oid = tbl.relnamespace
+JOIN pg_index ix
+  ON ix.indrelid = tbl.oid
+JOIN pg_class idx
+  ON idx.oid = ix.indexrelid
+JOIN LATERAL unnest(ix.indkey) WITH ORDINALITY AS ord(attnum, ordinality)
+  ON true
+JOIN pg_attribute att
+  ON att.attrelid = tbl.oid
+ AND att.attnum = ord.attnum
+WHERE tbl.relkind = 'r'
+  AND ns.nspname NOT IN ('pg_catalog', 'information_schema')
+  AND ix.indisprimary = false
+ORDER BY ns.nspname, tbl.relname, idx.relname, ord.ordinality
+`;
+async function inspectPostgreSQL(runQueryRows) {
+  const tableRows = await runQueryRows(POSTGRES_TABLES_QUERY);
+  const tableMap2 = createTableMap(
+    tableRows.map((row) => ({
+      schemaName: toOptionalStringValue(row.schema_name),
+      tableName: toStringValue(row.table_name)
+    }))
+  );
+  const columnsRows = await runQueryRows(POSTGRES_COLUMNS_QUERY);
+  for (const row of columnsRows) {
+    const table = getTableFromRow(tableMap2, row, "table_name", "schema_name");
+    if (!table) {
+      continue;
+    }
+    table.columns.push(createColumnSchema(row));
+  }
+  const primaryKeyRows = await runQueryRows(POSTGRES_PRIMARY_KEYS_QUERY);
+  for (const row of primaryKeyRows) {
+    const table = getTableFromRow(tableMap2, row, "table_name", "schema_name");
+    if (!table) {
+      continue;
+    }
+    applyPrimaryKeyColumn(table, toStringValue(row.column_name));
+  }
+  const foreignKeyRows = await runQueryRows(POSTGRES_FOREIGN_KEYS_QUERY);
+  for (const row of foreignKeyRows) {
+    const table = getTableFromRow(tableMap2, row, "table_name", "schema_name");
+    if (!table) {
+      continue;
+    }
+    const foreignKey = {
+      name: toOptionalStringValue(row.constraint_name),
+      column: toStringValue(row.column_name),
+      referencedSchema: toOptionalStringValue(row.referenced_schema_name),
+      referencedTable: toStringValue(row.referenced_table_name),
+      referencedColumn: toStringValue(row.referenced_column_name)
+    };
+    table.foreignKeys.push(foreignKey);
+  }
+  const indexRows = await runQueryRows(POSTGRES_INDEXES_QUERY);
+  applyIndexRows(tableMap2, indexRows, "table_name", "schema_name", {
+    indexNameField: "index_name",
+    columnField: "column_name",
+    positionField: "column_position",
+    uniqueResolver: (row) => toBooleanValue(row.is_unique)
+  });
+  return Array.from(tableMap2.values());
+}
+
+// src/data/relational/schema/schema-inspector-sqlite.ts
+var SQLITE_TABLES_QUERY = `
+SELECT
+  name AS table_name
+FROM sqlite_master
+WHERE type = 'table'
+  AND name NOT LIKE 'sqlite_%'
+ORDER BY name
+`;
+async function inspectSQLite(runQueryRows) {
+  const tableRows = await runQueryRows(SQLITE_TABLES_QUERY);
+  const tableMap2 = createTableMap(
+    tableRows.map((row) => ({
+      tableName: toStringValue(row.table_name)
+    }))
+  );
+  for (const table of tableMap2.values()) {
+    const tableLiteral = escapeSqliteStringLiteral(table.name);
+    const columnRows = await runQueryRows(`PRAGMA table_info('${tableLiteral}')`);
+    const primaryKeyColumns = [];
+    for (const row of columnRows) {
+      const pkPosition = toNumberValue(row.pk);
+      const columnName = toStringValue(row.name);
+      if (pkPosition > 0) {
+        primaryKeyColumns.push({ position: pkPosition, column: columnName });
+      }
+      const column = createColumnSchema(row, {
+        name: "name",
+        type: "type",
+        nullable: "notnull",
+        defaultValue: "dflt_value",
+        primaryKey: pkPosition > 0
+      });
+      column.isNullable = !toBooleanValue(row.notnull);
+      table.columns.push(column);
+    }
+    table.primaryKey = sortColumnsByPosition(primaryKeyColumns);
+    const foreignKeyRows = await runQueryRows(`PRAGMA foreign_key_list('${tableLiteral}')`);
+    for (const row of foreignKeyRows) {
+      const foreignKey = {
+        column: toStringValue(row.from),
+        referencedTable: toStringValue(row.table),
+        referencedColumn: toStringValue(row.to)
+      };
+      table.foreignKeys.push(foreignKey);
+    }
+    const indexListRows = await runQueryRows(`PRAGMA index_list('${tableLiteral}')`);
+    for (const indexRow of indexListRows) {
+      const indexName = toStringValue(indexRow.name);
+      if (!indexName || toStringValue(indexRow.origin) === "pk") {
+        continue;
+      }
+      const indexNameLiteral = escapeSqliteStringLiteral(indexName);
+      const indexInfoRows = await runQueryRows(`PRAGMA index_info('${indexNameLiteral}')`);
+      const indexColumns = sortColumnsByPosition(
+        indexInfoRows.map((row) => ({
+          position: toNumberValue(row.seqno),
+          column: toStringValue(row.name)
+        }))
+      );
+      const index = {
+        name: indexName,
+        isUnique: toBooleanValue(indexRow.unique),
+        columns: indexColumns
+      };
+      table.indexes.push(index);
+    }
+  }
+  return Array.from(tableMap2.values());
+}
+
+// src/data/relational/schema/schema-inspector.ts
+var logger13 = createLogger("agentforge:tools:data:relational:schema-inspector");
+var DEFAULT_CACHE_TTL_MS = 6e4;
+var schemaCache = /* @__PURE__ */ new Map();
 var SchemaInspector = class _SchemaInspector {
-  /**
-   * Create a new SchemaInspector.
-   *
-   * @param manager - ConnectionManager instance for database access
-   * @param vendor - Database vendor ('postgresql' | 'mysql' | 'sqlite')
-   * @param config - Optional configuration for cache TTL and cache key
-   */
   constructor(manager, vendor, config) {
     this.manager = manager;
     this.vendor = vendor;
@@ -6295,11 +6523,6 @@ var SchemaInspector = class _SchemaInspector {
   }
   cacheTtlMs;
   cacheKey;
-  /**
-   * Clear cached schema data.
-   *
-   * @param cacheKey - Specific cache key to clear. If omitted, clears all cached schemas.
-   */
   static clearCache(cacheKey) {
     if (cacheKey) {
       schemaCache.delete(cacheKey);
@@ -6307,18 +6530,9 @@ var SchemaInspector = class _SchemaInspector {
     }
     schemaCache.clear();
   }
-  /** Invalidate this inspector's cached schema, if any. */
   invalidateCache() {
     _SchemaInspector.clearCache(this.cacheKey);
   }
-  /**
-   * Inspect the database schema and return structured metadata.
-   *
-   * Results are cached when a `cacheKey` was provided at construction time.
-   *
-   * @param options - Optional table filters and cache bypass flag
-   * @returns Structured schema with tables, columns, indexes, and foreign keys
-   */
   async inspect(options) {
     const tableFilters = validateTableFilters(options?.tables);
     const bypassCache = options?.bypassCache ?? false;
@@ -6339,7 +6553,7 @@ var SchemaInspector = class _SchemaInspector {
     return filterSchemaTables(cloneSchema(schema), tableFilters);
   }
   async inspectFromDatabase() {
-    const tables = this.vendor === "postgresql" ? await this.inspectPostgreSQL() : this.vendor === "mysql" ? await this.inspectMySQL() : await this.inspectSQLite();
+    const tables = await this.inspectTables();
     return {
       vendor: this.vendor,
       tables: tables.sort((left, right) => {
@@ -6350,6 +6564,18 @@ var SchemaInspector = class _SchemaInspector {
       generatedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
   }
+  async inspectTables() {
+    switch (this.vendor) {
+      case "postgresql":
+        return inspectPostgreSQL((query) => this.runQueryRows(query));
+      case "mysql":
+        return inspectMySQL((query) => this.runQueryRows(query));
+      case "sqlite":
+        return inspectSQLite((query) => this.runQueryRows(query));
+      default:
+        throw new Error(`Unsupported database vendor: ${String(this.vendor)}`);
+    }
+  }
   async runQueryRows(query) {
     const result = await executeQuery2(this.manager, {
       sql: query,
@@ -6357,240 +6583,6 @@ var SchemaInspector = class _SchemaInspector {
     });
     return result.rows;
   }
-  createTableMap(refs) {
-    const tableMap2 = /* @__PURE__ */ new Map();
-    for (const ref of refs) {
-      const key = buildTableKey(ref.tableName, ref.schemaName);
-      tableMap2.set(key, {
-        name: ref.tableName,
-        schema: ref.schemaName,
-        columns: [],
-        primaryKey: [],
-        foreignKeys: [],
-        indexes: []
-      });
-    }
-    return tableMap2;
-  }
-  getTableFromRow(tableMap2, row, tableField, schemaField) {
-    const tableName = toStringValue(row[tableField]);
-    const schemaName = schemaField ? toOptionalStringValue(row[schemaField]) : void 0;
-    const key = buildTableKey(tableName, schemaName);
-    return tableMap2.get(key);
-  }
-  async inspectPostgreSQL() {
-    const tableRows = await this.runQueryRows(POSTGRES_TABLES_QUERY);
-    const tableMap2 = this.createTableMap(
-      tableRows.map((row) => ({
-        schemaName: toOptionalStringValue(row.schema_name),
-        tableName: toStringValue(row.table_name)
-      }))
-    );
-    const columnsRows = await this.runQueryRows(POSTGRES_COLUMNS_QUERY);
-    for (const row of columnsRows) {
-      const table = this.getTableFromRow(tableMap2, row, "table_name", "schema_name");
-      if (!table) {
-        continue;
-      }
-      const column = {
-        name: toStringValue(row.column_name),
-        type: toStringValue(row.data_type),
-        isNullable: toBooleanValue(row.is_nullable),
-        defaultValue: row.column_default ?? null,
-        isPrimaryKey: false
-      };
-      table.columns.push(column);
-    }
-    const primaryKeyRows = await this.runQueryRows(POSTGRES_PRIMARY_KEYS_QUERY);
-    for (const row of primaryKeyRows) {
-      const table = this.getTableFromRow(tableMap2, row, "table_name", "schema_name");
-      if (!table) {
-        continue;
-      }
-      const columnName = toStringValue(row.column_name);
-      table.primaryKey.push(columnName);
-      const column = table.columns.find((entry) => entry.name === columnName);
-      if (column) {
-        column.isPrimaryKey = true;
-      }
-    }
-    const foreignKeyRows = await this.runQueryRows(POSTGRES_FOREIGN_KEYS_QUERY);
-    for (const row of foreignKeyRows) {
-      const table = this.getTableFromRow(tableMap2, row, "table_name", "schema_name");
-      if (!table) {
-        continue;
-      }
-      const foreignKey = {
-        name: toOptionalStringValue(row.constraint_name),
-        column: toStringValue(row.column_name),
-        referencedSchema: toOptionalStringValue(row.referenced_schema_name),
-        referencedTable: toStringValue(row.referenced_table_name),
-        referencedColumn: toStringValue(row.referenced_column_name)
-      };
-      table.foreignKeys.push(foreignKey);
-    }
-    const indexRows = await this.runQueryRows(POSTGRES_INDEXES_QUERY);
-    this.applyIndexRows(tableMap2, indexRows, "table_name", "schema_name", {
-      indexNameField: "index_name",
-      columnField: "column_name",
-      positionField: "column_position",
-      uniqueResolver: (row) => toBooleanValue(row.is_unique)
-    });
-    return Array.from(tableMap2.values());
-  }
-  async inspectMySQL() {
-    const tableRows = await this.runQueryRows(MYSQL_TABLES_QUERY);
-    const tableMap2 = this.createTableMap(
-      tableRows.map((row) => ({
-        schemaName: toOptionalStringValue(row.schema_name),
-        tableName: toStringValue(row.table_name)
-      }))
-    );
-    const columnsRows = await this.runQueryRows(MYSQL_COLUMNS_QUERY);
-    for (const row of columnsRows) {
-      const table = this.getTableFromRow(tableMap2, row, "table_name", "schema_name");
-      if (!table) {
-        continue;
-      }
-      const column = {
-        name: toStringValue(row.column_name),
-        type: toStringValue(row.data_type),
-        isNullable: toBooleanValue(row.is_nullable),
-        defaultValue: row.column_default ?? null,
-        isPrimaryKey: false
-      };
-      table.columns.push(column);
-    }
-    const primaryKeyRows = await this.runQueryRows(MYSQL_PRIMARY_KEYS_QUERY);
-    for (const row of primaryKeyRows) {
-      const table = this.getTableFromRow(tableMap2, row, "table_name", "schema_name");
-      if (!table) {
-        continue;
-      }
-      const columnName = toStringValue(row.column_name);
-      table.primaryKey.push(columnName);
-      const column = table.columns.find((entry) => entry.name === columnName);
-      if (column) {
-        column.isPrimaryKey = true;
-      }
-    }
-    const foreignKeyRows = await this.runQueryRows(MYSQL_FOREIGN_KEYS_QUERY);
-    for (const row of foreignKeyRows) {
-      const table = this.getTableFromRow(tableMap2, row, "table_name", "schema_name");
-      if (!table) {
-        continue;
-      }
-      const foreignKey = {
-        name: toOptionalStringValue(row.constraint_name),
-        column: toStringValue(row.column_name),
-        referencedSchema: toOptionalStringValue(row.referenced_schema_name),
-        referencedTable: toStringValue(row.referenced_table_name),
-        referencedColumn: toStringValue(row.referenced_column_name)
-      };
-      table.foreignKeys.push(foreignKey);
-    }
-    const indexRows = await this.runQueryRows(MYSQL_INDEXES_QUERY);
-    this.applyIndexRows(tableMap2, indexRows, "table_name", "schema_name", {
-      indexNameField: "index_name",
-      columnField: "column_name",
-      positionField: "seq_in_index",
-      uniqueResolver: (row) => !toBooleanValue(row.non_unique)
-    });
-    return Array.from(tableMap2.values());
-  }
-  async inspectSQLite() {
-    const tableRows = await this.runQueryRows(SQLITE_TABLES_QUERY);
-    const tableMap2 = this.createTableMap(
-      tableRows.map((row) => ({
-        tableName: toStringValue(row.table_name)
-      }))
-    );
-    for (const table of tableMap2.values()) {
-      const tableLiteral = escapeSqliteStringLiteral(table.name);
-      const columnRows = await this.runQueryRows(`PRAGMA table_info('${tableLiteral}')`);
-      const primaryKeyColumns = [];
-      for (const row of columnRows) {
-        const pkPosition = toNumberValue(row.pk);
-        const columnName = toStringValue(row.name);
-        if (pkPosition > 0) {
-          primaryKeyColumns.push({ position: pkPosition, column: columnName });
-        }
-        const column = {
-          name: columnName,
-          type: toStringValue(row.type),
-          isNullable: !toBooleanValue(row.notnull),
-          defaultValue: row.dflt_value ?? null,
-          isPrimaryKey: pkPosition > 0
-        };
-        table.columns.push(column);
-      }
-      table.primaryKey = sortColumnsByPosition(primaryKeyColumns);
-      const foreignKeyRows = await this.runQueryRows(`PRAGMA foreign_key_list('${tableLiteral}')`);
-      for (const row of foreignKeyRows) {
-        const foreignKey = {
-          column: toStringValue(row.from),
-          referencedTable: toStringValue(row.table),
-          referencedColumn: toStringValue(row.to)
-        };
-        table.foreignKeys.push(foreignKey);
-      }
-      const indexListRows = await this.runQueryRows(`PRAGMA index_list('${tableLiteral}')`);
-      for (const indexRow of indexListRows) {
-        const indexName = toStringValue(indexRow.name);
-        if (!indexName || toStringValue(indexRow.origin) === "pk") {
-          continue;
-        }
-        const indexNameLiteral = escapeSqliteStringLiteral(indexName);
-        const indexInfoRows = await this.runQueryRows(`PRAGMA index_info('${indexNameLiteral}')`);
-        const indexColumns = sortColumnsByPosition(
-          indexInfoRows.map((row) => ({
-            position: toNumberValue(row.seqno),
-            column: toStringValue(row.name)
-          }))
-        );
-        const index = {
-          name: indexName,
-          isUnique: toBooleanValue(indexRow.unique),
-          columns: indexColumns
-        };
-        table.indexes.push(index);
-      }
-    }
-    return Array.from(tableMap2.values());
-  }
-  applyIndexRows(tableMap2, rows, tableField, schemaField, config) {
-    const grouped = /* @__PURE__ */ new Map();
-    for (const row of rows) {
-      const table = this.getTableFromRow(tableMap2, row, tableField, schemaField);
-      if (!table) {
-        continue;
-      }
-      const indexName = toStringValue(row[config.indexNameField]);
-      if (!indexName) {
-        continue;
-      }
-      const groupKey = `${table.schema ?? ""}.${table.name}.${indexName}`;
-      const entry = grouped.get(groupKey) ?? {
-        table,
-        indexName,
-        isUnique: config.uniqueResolver(row),
-        columnsByPosition: []
-      };
-      entry.columnsByPosition.push({
-        position: toNumberValue(row[config.positionField]),
-        column: toStringValue(row[config.columnField])
-      });
-      grouped.set(groupKey, entry);
-    }
-    for (const entry of grouped.values()) {
-      const index = {
-        name: entry.indexName,
-        isUnique: entry.isUnique,
-        columns: sortColumnsByPosition(entry.columnsByPosition)
-      };
-      entry.table.indexes.push(index);
-    }
-  }
 };
 var logger14 = createLogger("agentforge:tools:data:relational:schema-validator");
 function validateTableExists(schema, tableName) {