sandal-db 1.0.7 → 1.0.8

package/README.md

@@ -136,7 +136,7 @@ npx sandal-db@latest md [options] [fileOrText]
 | `-k, --key <key>`       | `string`  | API key corresponding to the selected provider.                                    | Environment / Config |
 | `--strict`              | `boolean` | Hard-blocks full database drops and bulk table truncations.                        | `true`               |
 | `--no-strict`           | `flag`    | Disables strict safety mode.                                                       | `false`              |
-| `--allow-full-wipe`     | `flag`    | Explicitly permits database-level drops after interactive phrase confirmation.     | `false`              |
+| `--allow-full-wipe`     | `flag`    | Explicitly permits full database wipes and db admin tasks after interactive confirmation. | `false`              |
 | `--threshold <number>`  | `integer` | Row count threshold above which updates are classified as dangerous operations.    | `50`                 |
 | `--markdown`            | `boolean` | Formats and renders LLM responses as rich terminal markdown.                       | `true`               |
 | `--no-markdown`         | `flag`    | Disables terminal markdown rendering and outputs raw text.                         | `false`              |
@@ -404,16 +404,16 @@ Any mutation query lacking a filter or `WHERE` clause poses extreme operational
 ? Destructive operation with no filter. Type "DELETE ALL" to confirm:
 ```
 
-### 6. Strict Mode and Full-Wipe Hard Blocking
+### 6. Strict Mode, Full-Wipe, and Admin Tasks Guardrails
 
-By default, `--strict` mode is enabled. Any operation that attempts to drop an entire database or drop all tables is blocked unconditionally:
+By default, `--strict` mode is enabled and `--allow-full-wipe` is disabled. Any operation that attempts to drop an entire database, drop all tables, or execute database administration tasks (e.g. user/role drops, privilege changes, maintenance locks, backend termination) is blocked unconditionally:
 
 ```text
-Operation blocked by --strict mode: full database or all-table drop is prohibited.
+Operation blocked by --strict mode: database admin tasks are prohibited.
 To allow this, start sandal-db with --allow-full-wipe.
 ```
 
-To permit database-level destructions, the user must explicitly supply `--allow-full-wipe` at startup and subsequently type the required confirmation string during interactive execution.
+To permit database-level destructions and administrative tasks, the user must explicitly supply `--allow-full-wipe` at startup and subsequently confirm the operation during interactive execution.
 
 ---
 

package/dist/cli.js

@@ -916,16 +916,33 @@ var PostgresAdapter = class {
     const startTime = Date.now();
     const client = await this.pool.connect();
     try {
-      const res = await client.query(sql, query.params || []);
+      const hasParams = Array.isArray(query.params) && query.params.length > 0;
+      const res = hasParams ? await client.query(sql, query.params) : await client.query(sql);
       const durationMs = Date.now() - startTime;
       let rows = [];
       let fields = [];
       let rowCount = 0;
       if (Array.isArray(res)) {
+        let totalAffected = 0;
+        const allRows = [];
+        let lastFields = [];
+        for (const stmtRes of res) {
+          if (stmtRes) {
+            if (typeof stmtRes.rowCount === "number") {
+              totalAffected += stmtRes.rowCount;
+            }
+            if (stmtRes.rows && stmtRes.rows.length > 0) {
+              allRows.push(...stmtRes.rows);
+            }
+            if (stmtRes.fields && stmtRes.fields.length > 0) {
+              lastFields = stmtRes.fields.map((f) => f.name);
+            }
+          }
+        }
         const lastResult = res[res.length - 1];
-        rows = lastResult?.rows || [];
-        fields = (lastResult?.fields || []).map((f) => f.name);
-        rowCount = lastResult?.rowCount ?? rows.length;
+        rows = allRows.length > 0 ? allRows : lastResult?.rows || [];
+        fields = lastFields.length > 0 ? lastFields : (lastResult?.fields || []).map((f) => f.name);
+        rowCount = totalAffected > 0 ? totalAffected : lastResult?.rowCount ?? rows.length;
       } else if (res) {
         rows = res.rows || [];
         fields = (res.fields || []).map((f) => f.name);
@@ -938,7 +955,7 @@ var PostgresAdapter = class {
         rowCount,
         affectedRows: rowCount,
         durationMs,
-        command: Array.isArray(res) ? res[res.length - 1]?.command : res?.command
+        command: Array.isArray(res) ? res.map((r) => r?.command).filter(Boolean).join("; ") : res?.command
       };
     } catch (err) {
       const durationMs = Date.now() - startTime;
@@ -1168,6 +1185,39 @@ var MongoAdapter = class {
           rows: [result]
         };
       }
+      let operationsList = query.operations;
+      if (!operationsList && typeof query.rawDisplay === "string") {
+        try {
+          const parsedDisplay = JSON.parse(query.rawDisplay);
+          if (Array.isArray(parsedDisplay.operations)) {
+            operationsList = parsedDisplay.operations;
+          }
+        } catch {
+        }
+      }
+      if (Array.isArray(operationsList) && operationsList.length > 0) {
+        let totalAffected = 0;
+        const allRows = [];
+        for (const op of operationsList) {
+          const subResult = await this.executeQuery({
+            ...op,
+            rawDisplay: typeof op === "string" ? op : JSON.stringify(op)
+          });
+          if (!subResult.success) {
+            return subResult;
+          }
+          totalAffected += subResult.affectedRows ?? subResult.rowCount ?? 0;
+          if (subResult.rows) allRows.push(...subResult.rows);
+        }
+        return {
+          success: true,
+          rows: allRows,
+          rowCount: allRows.length,
+          affectedRows: totalAffected,
+          durationMs: Date.now() - startTime,
+          command: "multi-operation"
+        };
+      }
       let collectionName = query.collection;
       let operation = query.operation;
       let filter = query.filter || {};
@@ -1191,6 +1241,19 @@ var MongoAdapter = class {
         }
       }
       if (!collectionName) {
+        if (operation === "dropDatabase") {
+          const res = await db.dropDatabase();
+          const durationMs2 = Date.now() - startTime;
+          return {
+            success: true,
+            rows: [{ droppedDatabase: res }],
+            rowCount: res ? 1 : 0,
+            affectedRows: 0,
+            fields: ["droppedDatabase"],
+            durationMs: durationMs2,
+            command: "dropDatabase"
+          };
+        }
         throw new Error("Mongo operation requires a target collection.");
       }
       const collection = db.collection(collectionName);
@@ -1280,6 +1343,12 @@ var MongoAdapter = class {
           rowCount = 1;
           break;
         }
+        case "dropDatabase": {
+          const res = await db.dropDatabase();
+          rows = [{ droppedDatabase: res }];
+          rowCount = res ? 1 : 0;
+          break;
+        }
         default:
           throw new Error(`Unsupported MongoDB operation: ${operation}`);
       }
@@ -1308,6 +1377,15 @@ var MongoAdapter = class {
       await this.connect();
     }
     try {
+      if (Array.isArray(query.operations)) {
+        let total = 0;
+        for (const op of query.operations) {
+          const opObj = typeof op === "object" && op !== null && op.rawDisplay ? op : { ...op, rawDisplay: JSON.stringify(op) };
+          const count = await this.dryRunCount(opObj);
+          if (count !== null) total += count;
+        }
+        return total > 0 ? total : null;
+      }
       let collectionName = query.collection;
       let operation = query.operation;
       let filter = query.filter || {};
@@ -1523,6 +1601,7 @@ function classifyPostgresQuery(sql, query, rowThreshold, options) {
       isDestructive: true,
       isStructural: false,
       isFullWipe: true,
+      isAdmin: true,
       requiresLiteralWord: true,
       literalWord: "DROP DATABASE",
       hasWhereClause: false,
@@ -1530,94 +1609,89 @@ function classifyPostgresQuery(sql, query, rowThreshold, options) {
       explanation: "Permanently deletes database or schema cascade."
     };
   }
-  const isCreateIndex = /CREATE\s+(UNIQUE\s+)?INDEX/i.test(cleanSql);
-  const isCreateTable = /CREATE\s+TABLE/i.test(cleanSql);
-  const isCreateSchema = /CREATE\s+SCHEMA/i.test(cleanSql);
-  const isAlterAdd = /ALTER\s+TABLE\s+([^\s;]+)\s+ADD\s+(COLUMN|CONSTRAINT)/i.test(cleanSql);
-  const isAlterOtherSafe = /ALTER\s+TABLE\s+([^\s;]+)\s+(ALTER\s+COLUMN|RENAME)/i.test(cleanSql);
-  if (isCreateIndex) {
-    const isConcurrently = /CREATE\s+(UNIQUE\s+)?INDEX\s+CONCURRENTLY/i.test(cleanSql);
-    let suggestion;
-    if (!isConcurrently) {
-      warnings.push(
-        "Index is not being created CONCURRENTLY. This will lock write operations on the table during index creation."
-      );
-      suggestion = cleanSql.replace(/CREATE\s+(UNIQUE\s+)?INDEX/i, (m) => `${m} CONCURRENTLY`);
-    }
-    const tableMatch = cleanSql.match(/ON\s+([^\s;(]+)/i);
-    const tableName = tableMatch ? tableMatch[1] : void 0;
+  const isUserOrRole = /^(?:CREATE|ALTER|DROP)\s+(?:USER|ROLE)\b/i.test(cleanSql);
+  if (isUserOrRole) {
+    const isDrop = /^DROP\s+(?:USER|ROLE)\b/i.test(cleanSql);
+    const isRole = /\bROLE\b/i.test(cleanSql);
+    const word = isRole ? "DROP ROLE" : "DROP USER";
     return {
-      category: "structural",
-      isDestructive: false,
-      isStructural: true,
+      category: "admin",
+      isDestructive: isDrop,
+      isStructural: false,
       isFullWipe: false,
-      requiresLiteralWord: false,
+      isAdmin: true,
+      requiresLiteralWord: isDrop,
+      literalWord: isDrop ? word : void 0,
       hasWhereClause: false,
-      tableOrCollection: tableName,
-      explanation: `Creates an index on ${tableName || "table"}${isConcurrently ? " concurrently (non-blocking)" : " (may lock table during build)"}.`,
-      warnings,
-      suggestedAlternative: suggestion
+      warnings: isDrop ? ["Permanently deletes database credentials and associated privileges."] : [],
+      explanation: `${isDrop ? "Drops" : "Manages"} database ${isRole ? "role" : "user"}.`
     };
   }
-  if (isCreateTable) {
-    const match = cleanSql.match(/CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?([^\s;(]+)/i);
-    const tableName = match ? match[1] : void 0;
+  const isGrant = /^GRANT\s+/i.test(cleanSql);
+  const isRevoke = /^REVOKE\s+/i.test(cleanSql);
+  if (isGrant || isRevoke) {
     return {
-      category: "structural",
+      category: "admin",
       isDestructive: false,
-      isStructural: true,
+      isStructural: false,
       isFullWipe: false,
+      isAdmin: true,
       requiresLiteralWord: false,
       hasWhereClause: false,
-      tableOrCollection: tableName,
-      explanation: `Creates a new table "${tableName || "unknown"}".`,
-      warnings
+      warnings: isRevoke ? ["Revoking privileges modifies access control permissions."] : [],
+      explanation: isGrant ? "Grants database privileges." : "Revokes database privileges."
     };
   }
-  if (isCreateSchema) {
-    const match = cleanSql.match(/CREATE\s+SCHEMA\s+(?:IF\s+NOT\s+EXISTS\s+)?([^\s;(]+)/i);
-    const schemaName = match ? match[1] : void 0;
+  const isVacuum = /^VACUUM\b/i.test(cleanSql);
+  const isAnalyze = /^ANALYZE\b/i.test(cleanSql);
+  const isReindex = /^REINDEX\b/i.test(cleanSql);
+  const isCheckpoint = /^CHECKPOINT\b/i.test(cleanSql);
+  if (isVacuum || isAnalyze || isReindex || isCheckpoint) {
+    const isVacuumFull = /^VACUUM\s+FULL\b/i.test(cleanSql);
+    const maintenanceWarnings = [];
+    if (isVacuumFull) {
+      maintenanceWarnings.push(
+        "VACUUM FULL exclusively locks tables and may cause operational downtime on active tables."
+      );
+    }
     return {
-      category: "structural",
+      category: "admin",
       isDestructive: false,
-      isStructural: true,
+      isStructural: false,
       isFullWipe: false,
+      isAdmin: true,
       requiresLiteralWord: false,
       hasWhereClause: false,
-      tableOrCollection: schemaName,
-      explanation: `Creates a new schema "${schemaName || "unknown"}".`,
-      warnings
+      warnings: maintenanceWarnings,
+      explanation: isVacuum ? "Performs database vacuum maintenance." : isReindex ? "Reindexes database tables or indexes." : isAnalyze ? "Collects database statistics for query planner." : "Forces a database checkpoint."
     };
   }
-  if (isAlterAdd || isAlterOtherSafe) {
-    const match = cleanSql.match(/ALTER\s+TABLE\s+([^\s;(]+)/i);
-    const tableName = match ? match[1] : void 0;
+  const isAlterSystemOrDb = /^ALTER\s+(?:SYSTEM|DATABASE)\b/i.test(cleanSql);
+  if (isAlterSystemOrDb) {
     return {
-      category: "structural",
+      category: "admin",
       isDestructive: false,
-      isStructural: true,
+      isStructural: false,
       isFullWipe: false,
+      isAdmin: true,
       requiresLiteralWord: false,
       hasWhereClause: false,
-      tableOrCollection: tableName,
-      explanation: `Alters table "${tableName || "unknown"}" to add or modify structural attributes.`,
-      warnings
+      warnings: ["Alters database server or cluster configuration settings."],
+      explanation: "Modifies database or system-level configuration."
     };
   }
-  const isAlterDrop = /ALTER\s+TABLE\s+([^\s;]+)\s+DROP\s+COLUMN/i.test(cleanSql);
-  if (isAlterDrop) {
-    const match = cleanSql.match(/ALTER\s+TABLE\s+([^\s;(]+)/i);
-    const tableName = match ? match[1] : void 0;
+  const isKillBackend = /\bpg_(?:terminate|cancel)_backend\s*\(/i.test(cleanSql);
+  if (isKillBackend) {
     return {
-      category: "dangerous",
+      category: "admin",
       isDestructive: true,
       isStructural: false,
       isFullWipe: false,
+      isAdmin: true,
       requiresLiteralWord: false,
       hasWhereClause: false,
-      tableOrCollection: tableName,
-      explanation: `Removes a column from table "${tableName || "unknown"}", permanently discarding column data.`,
-      warnings: ["Removing a column is permanent and irreversible."]
+      warnings: ["Terminates active database backend connection process."],
+      explanation: "Terminates active backend query connection."
     };
   }
   const isDropTable = /DROP\s+TABLE/i.test(cleanSql);
@@ -1638,9 +1712,25 @@ function classifyPostgresQuery(sql, query, rowThreshold, options) {
       warnings: ["All rows will be permanently deleted."]
     };
   }
-  const isDelete = /^DELETE\s+FROM/i.test(cleanSql);
+  const isAlterDrop = /ALTER\s+TABLE\s+([^\s;]+)\s+DROP\s+COLUMN/i.test(cleanSql);
+  if (isAlterDrop) {
+    const match = cleanSql.match(/ALTER\s+TABLE\s+([^\s;(]+)/i);
+    const tableName = match ? match[1] : void 0;
+    return {
+      category: "dangerous",
+      isDestructive: true,
+      isStructural: false,
+      isFullWipe: false,
+      requiresLiteralWord: false,
+      hasWhereClause: false,
+      tableOrCollection: tableName,
+      explanation: `Removes a column from table "${tableName || "unknown"}", permanently discarding column data.`,
+      warnings: ["Removing a column is permanent and irreversible."]
+    };
+  }
+  const isDelete = /\bDELETE\s+FROM\b/i.test(cleanSql);
   if (isDelete) {
-    const match = cleanSql.match(/^DELETE\s+FROM\s+([^\s;(]+)(?:\s+WHERE\s+([\s\S]+))?/i);
+    const match = cleanSql.match(/DELETE\s+FROM\s+([^\s;(]+)(?:\s+WHERE\s+([\s\S]+?))?(?:;|$)/i);
     const tableName = match ? match[1] : void 0;
     const hasWhere = Boolean(match && match[2] && match[2].trim().length > 0);
     if (!hasWhere) {
@@ -1657,21 +1747,10 @@ function classifyPostgresQuery(sql, query, rowThreshold, options) {
         warnings: ["No WHERE clause specified: EVERY row in the table will be deleted!"]
       };
     }
-    return {
-      category: "dangerous",
-      isDestructive: true,
-      isStructural: false,
-      isFullWipe: false,
-      requiresLiteralWord: false,
-      hasWhereClause: true,
-      tableOrCollection: tableName,
-      explanation: `Deletes filtered rows from table "${tableName || "unknown"}".`,
-      warnings: ["Mutates existing database records."]
-    };
   }
-  const isUpdate = /^UPDATE\s+/i.test(cleanSql);
+  const isUpdate = /\bUPDATE\s+[^\s;(]+\s+SET\b/i.test(cleanSql);
   if (isUpdate) {
-    const match = cleanSql.match(/^UPDATE\s+([^\s;(]+)\s+SET\s+[\s\S]+?(?:\s+WHERE\s+([\s\S]+))?$/i);
+    const match = cleanSql.match(/UPDATE\s+([^\s;(]+)\s+SET\s+[\s\S]+?(?:\s+WHERE\s+([\s\S]+?))?(?:;|$)/i);
     const tableName = match ? match[1] : void 0;
     const hasWhere = Boolean(match && match[2] && match[2].trim().length > 0);
     if (!hasWhere) {
@@ -1688,6 +1767,101 @@ function classifyPostgresQuery(sql, query, rowThreshold, options) {
         warnings: ["No WHERE clause specified: EVERY row in the table will be updated!"]
       };
     }
+  }
+  const isCreateIndex = /CREATE\s+(UNIQUE\s+)?INDEX/i.test(cleanSql);
+  const isCreateTable = /CREATE\s+TABLE/i.test(cleanSql);
+  const isCreateSchema = /CREATE\s+SCHEMA/i.test(cleanSql);
+  const isAlterAdd = /ALTER\s+TABLE\s+([^\s;]+)\s+ADD\s+(COLUMN|CONSTRAINT)/i.test(cleanSql);
+  const isAlterOtherSafe = /ALTER\s+TABLE\s+([^\s;]+)\s+(ALTER\s+COLUMN|RENAME)/i.test(cleanSql);
+  if (isCreateIndex) {
+    const isConcurrently = /CREATE\s+(UNIQUE\s+)?INDEX\s+CONCURRENTLY/i.test(cleanSql);
+    let suggestion;
+    if (!isConcurrently) {
+      warnings.push(
+        "Index is not being created CONCURRENTLY. This will lock write operations on the table during index creation."
+      );
+      suggestion = cleanSql.replace(/CREATE\s+(UNIQUE\s+)?INDEX/i, (m) => `${m} CONCURRENTLY`);
+    }
+    const tableMatch = cleanSql.match(/ON\s+([^\s;(]+)/i);
+    const tableName = tableMatch ? tableMatch[1] : void 0;
+    return {
+      category: "structural",
+      isDestructive: false,
+      isStructural: true,
+      isFullWipe: false,
+      requiresLiteralWord: false,
+      hasWhereClause: false,
+      tableOrCollection: tableName,
+      explanation: `Creates an index on ${tableName || "table"}${isConcurrently ? " concurrently (non-blocking)" : " (may lock table during build)"}.`,
+      warnings,
+      suggestedAlternative: suggestion
+    };
+  }
+  if (isCreateTable) {
+    const tableMatches = [...cleanSql.matchAll(/CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?([^\s;(]+)/gi)].map((m) => m[1]);
+    const hasInserts = /\bINSERT\s+INTO\b/i.test(cleanSql);
+    const tableName = tableMatches[0] || "unknown";
+    const explanation = tableMatches.length > 1 ? `Creates tables (${tableMatches.join(", ")})${hasInserts ? " and populates seed data" : ""}.` : `Creates a new table "${tableName}"${hasInserts ? " and populates seed data" : ""}.`;
+    return {
+      category: "structural",
+      isDestructive: false,
+      isStructural: true,
+      isFullWipe: false,
+      requiresLiteralWord: false,
+      hasWhereClause: false,
+      tableOrCollection: tableName,
+      explanation,
+      warnings
+    };
+  }
+  if (isCreateSchema) {
+    const match = cleanSql.match(/CREATE\s+SCHEMA\s+(?:IF\s+NOT\s+EXISTS\s+)?([^\s;(]+)/i);
+    const schemaName = match ? match[1] : void 0;
+    return {
+      category: "structural",
+      isDestructive: false,
+      isStructural: true,
+      isFullWipe: false,
+      requiresLiteralWord: false,
+      hasWhereClause: false,
+      tableOrCollection: schemaName,
+      explanation: `Creates a new schema "${schemaName || "unknown"}".`,
+      warnings
+    };
+  }
+  if (isAlterAdd || isAlterOtherSafe) {
+    const match = cleanSql.match(/ALTER\s+TABLE\s+([^\s;(]+)/i);
+    const tableName = match ? match[1] : void 0;
+    return {
+      category: "structural",
+      isDestructive: false,
+      isStructural: true,
+      isFullWipe: false,
+      requiresLiteralWord: false,
+      hasWhereClause: false,
+      tableOrCollection: tableName,
+      explanation: `Alters table "${tableName || "unknown"}" to add or modify structural attributes.`,
+      warnings
+    };
+  }
+  if (isDelete) {
+    const match = cleanSql.match(/DELETE\s+FROM\s+([^\s;(]+)(?:\s+WHERE\s+([\s\S]+?))?(?:;|$)/i);
+    const tableName = match ? match[1] : void 0;
+    return {
+      category: "dangerous",
+      isDestructive: true,
+      isStructural: false,
+      isFullWipe: false,
+      requiresLiteralWord: false,
+      hasWhereClause: true,
+      tableOrCollection: tableName,
+      explanation: `Deletes filtered rows from table "${tableName || "unknown"}".`,
+      warnings: ["Mutates existing database records."]
+    };
+  }
+  if (isUpdate) {
+    const match = cleanSql.match(/UPDATE\s+([^\s;(]+)\s+SET\s+[\s\S]+?(?:\s+WHERE\s+([\s\S]+?))?(?:;|$)/i);
+    const tableName = match ? match[1] : void 0;
     return {
       category: "write",
       isDestructive: false,
@@ -1700,10 +1874,12 @@ function classifyPostgresQuery(sql, query, rowThreshold, options) {
       warnings: ["Mutates existing database records."]
     };
   }
-  const isInsert = /^INSERT\s+INTO/i.test(cleanSql);
+  const isInsert = /\bINSERT\s+INTO\b/i.test(cleanSql);
   if (isInsert) {
-    const match = cleanSql.match(/^INSERT\s+INTO\s+([^\s;(]+)/i);
-    const tableName = match ? match[1] : void 0;
+    const insertMatches = [...cleanSql.matchAll(/INSERT\s+INTO\s+([^\s;(]+)/gi)].map((m) => m[1]);
+    const uniqueTables = [...new Set(insertMatches)];
+    const tableName = uniqueTables[0] || "unknown";
+    const explanation = uniqueTables.length > 1 ? `Inserts new records into tables (${uniqueTables.join(", ")}).` : `Inserts new records into table "${tableName}".`;
     return {
       category: "write",
       isDestructive: false,
@@ -1712,7 +1888,7 @@ function classifyPostgresQuery(sql, query, rowThreshold, options) {
       requiresLiteralWord: false,
       hasWhereClause: false,
       tableOrCollection: tableName,
-      explanation: `Inserts new records into table "${tableName || "unknown"}".`,
+      explanation,
       warnings: []
     };
   }
@@ -1743,22 +1919,54 @@ function classifyMongoQuery(rawText, query, rowThreshold, options) {
   let collectionName = query.collection;
   let operation = query.operation;
   let filter = query.filter;
+  let operations = query.operations;
   if (!collectionName || !operation) {
     try {
       const parsed = JSON.parse(rawText);
       collectionName = parsed.collection || collectionName;
       operation = parsed.operation || operation;
       filter = parsed.filter || filter;
+      operations = parsed.operations || operations;
     } catch {
     }
   }
+  if (Array.isArray(operations) && operations.length > 0) {
+    const subClassifications = operations.map((op) => {
+      const display = typeof op === "string" ? op : op.rawDisplay || JSON.stringify(op);
+      const opObj = typeof op === "object" && op !== null && op.rawDisplay ? op : { ...op, rawDisplay: display };
+      return classifyMongoQuery(display, opObj, rowThreshold, options);
+    });
+    const fullWipe = subClassifications.find((c) => c.isFullWipe);
+    if (fullWipe) return fullWipe;
+    const admin = subClassifications.find((c) => c.category === "admin" || c.isAdmin);
+    if (admin) return admin;
+    const dangerous = subClassifications.find((c) => c.category === "dangerous");
+    if (dangerous) return dangerous;
+    const structural = subClassifications.find((c) => c.category === "structural");
+    if (structural) return structural;
+    const targetCols = [
+      ...new Set(operations.map((o) => o.collection).filter(Boolean))
+    ];
+    return {
+      category: "write",
+      isDestructive: false,
+      isStructural: false,
+      isFullWipe: false,
+      requiresLiteralWord: false,
+      hasWhereClause: false,
+      tableOrCollection: targetCols.join(", "),
+      explanation: `Executes batch operations across collections (${targetCols.join(", ")}).`,
+      warnings: []
+    };
+  }
   const warnings = [];
-  if (operation === "command" && (query.rawCommand?.dropDatabase || rawText.includes("dropDatabase"))) {
+  if (operation === "dropDatabase" || operation === "command" && (query.rawCommand?.dropDatabase || rawText.includes("dropDatabase"))) {
     return {
       category: "full_wipe",
       isDestructive: true,
       isStructural: false,
       isFullWipe: true,
+      isAdmin: true,
       requiresLiteralWord: true,
       literalWord: "DROP DATABASE",
       hasWhereClause: false,
@@ -1766,6 +1974,25 @@ function classifyMongoQuery(rawText, query, rowThreshold, options) {
       explanation: "Drops the entire database."
     };
   }
+  const isAdminCmd = operation === "createUser" || operation === "dropUser" || operation === "grantRolesToUser" || operation === "revokeRolesFromUser" || operation === "repairDatabase" || operation === "compact" || operation === "reIndex" || operation === "command" && Boolean(
+    query.rawCommand?.createUser || query.rawCommand?.dropUser || query.rawCommand?.grantRolesToUser || query.rawCommand?.revokeRolesFromUser || query.rawCommand?.repairDatabase || query.rawCommand?.compact || query.rawCommand?.reIndex || query.rawCommand?.killOp || query.rawCommand?.shutdown || rawText.includes("createUser") || rawText.includes("dropUser") || rawText.includes("killOp") || rawText.includes("repairDatabase")
+  );
+  if (isAdminCmd) {
+    const isDrop = operation === "dropUser" || query.rawCommand?.dropUser || rawText.includes("dropUser");
+    return {
+      category: "admin",
+      isDestructive: isDrop,
+      isStructural: false,
+      isFullWipe: false,
+      isAdmin: true,
+      requiresLiteralWord: isDrop,
+      literalWord: isDrop ? "DROP USER" : void 0,
+      hasWhereClause: false,
+      tableOrCollection: collectionName,
+      warnings: isDrop ? ["Permanently removes database user credentials and roles."] : [],
+      explanation: `Performs MongoDB administrative operation (${operation || "command"}).`
+    };
+  }
   if (operation === "createIndex") {
     const isBackground = query.options?.background === true;
     let suggestion;
@@ -2021,6 +2248,50 @@ async function requestUserConfirmation(query, safety, affectedRows, ask = defaul
     );
     return { confirmed: answer2 };
   }
+  if (safety.category === "admin" || safety.isAdmin) {
+    const lines2 = [
+      chalk2.bold.hex("#DA70D6")("\u{1F6E1}\uFE0F  DATABASE ADMIN OPERATION"),
+      "",
+      chalk2.white(queryDisplay),
+      "",
+      chalk2.hex("#DA70D6")(`Action: ${safety.explanation || "Administrative database operation."}`)
+    ];
+    if (safety.warnings.length > 0) {
+      lines2.push("");
+      for (const w of safety.warnings) {
+        lines2.push(chalk2.yellow(`\u2022 ${w}`));
+      }
+    }
+    console.log(
+      boxen(lines2.join("\n"), {
+        padding: 1,
+        borderColor: "magenta",
+        borderStyle: "round",
+        margin: { top: 1, bottom: 1 }
+      })
+    );
+    if (safety.requiresLiteralWord && safety.literalWord) {
+      const typed = await promptInput(
+        chalk2.hex("#DA70D6").bold(
+          `Administrative operation. Type "${safety.literalWord}" to confirm: `
+        ),
+        ask
+      );
+      if (typed.trim() === safety.literalWord) {
+        return { confirmed: true };
+      }
+      return {
+        confirmed: false,
+        reason: `Confirmation word mismatch (expected "${safety.literalWord}"). Operation cancelled.`
+      };
+    }
+    const answer2 = await promptConfirm(
+      chalk2.hex("#DA70D6").bold("Execute database admin operation?"),
+      false,
+      ask
+    );
+    return { confirmed: answer2 };
+  }
   if (safety.isStructural) {
     const lines2 = [
       chalk2.bold.cyan("\u{1F6E0}\uFE0F  STRUCTURAL DDL OPERATION"),
@@ -2107,7 +2378,8 @@ import { HumanMessage } from "@langchain/core/messages";
 
 // src/agent/prompts.ts
 var REFUSAL_MESSAGE = "I'm scoped to database operations on your connected DB only (schema inspection, queries, CRUD, analysis). I can't help with that here.";
-function getSystemPrompt(dbType, schemaSummary) {
+function getSystemPrompt(dbType, schemaSummary, options) {
+  const allowFullWipe = options?.allowFullWipe === true;
   return `You are "SANDAL" (Safe Agentic Natural-language Database Access Layer), an expert, production-grade agentic database assistant.
 You are connected directly to a live ${dbType === "postgres" ? "PostgreSQL" : "MongoDB"} database.
 
@@ -2119,6 +2391,9 @@ STRICT SCOPE & SAFETY RULES
    - Data analysis, querying, filtering, sorting, aggregations, and statistics
    - CRUD operations (SELECT/find, INSERT/insertOne, UPDATE/updateOne, DELETE/deleteOne)
    - Structural DDL operations (CREATE TABLE, CREATE INDEX, ALTER TABLE ADD COLUMN, createCollection, createIndex)
+   - Generating and seeding realistic fake, mock, or sample data across tables or collections
+   - You ARE fully authorized, equipped, and expected to generate DDL (CREATE TABLE) and DML (INSERT) to fulfill the user's database tasks.
+${allowFullWipe ? `   - Database administrative tasks and full database operations (e.g. DROP DATABASE, DROP SCHEMA CASCADE, user/role management like CREATE/ALTER/DROP USER/ROLE, GRANT/REVOKE privileges, maintenance tasks like VACUUM/REINDEX/CHECKPOINT, connection management like pg_terminate_backend/killOp, and admin commands)` : `   - Database administrative tasks (when requested, generate the appropriate query so security guardrails can inspect it)`}
 2. REFUSE ANY OUT-OF-SCOPE REQUEST:
    - If the user asks for general programming (e.g. "write a Python script", "build a web scraper"), general Q&A, creative writing, math tutoring, or any non-database task, politely refuse immediately with:
      "${REFUSAL_MESSAGE}"
@@ -2126,33 +2401,62 @@ STRICT SCOPE & SAFETY RULES
 4. NEVER expose raw credentials, passwords, or API keys in your responses.
 5. NEVER hallucinate data. Ground your answers ONLY in the actual query results returned from the database.
 
+${allowFullWipe ? `\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
+ADMIN & FULL-WIPE AUTHORIZATION (--allow-full-wipe ENABLED)
+\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
+\u2022 The user has launched SANDAL with --allow-full-wipe.
+\u2022 You ARE fully authorized to generate database administrative tasks, table drops, and full database wipes (such as DROP DATABASE, DROP SCHEMA CASCADE, CREATE/ALTER/DROP USER/ROLE, GRANT/REVOKE, VACUUM FULL, REINDEX, pg_terminate_backend, or MongoDB administrative commands).
+\u2022 When the user requests a database administration task or full wipe, fulfill it by generating the appropriate database query. Our multi-stage security pipeline will handle confirmation before execution.` : `\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
+ADMIN & FULL-WIPE SAFETY (--allow-full-wipe DISABLED)
+\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
+\u2022 Full database drops and destructive database admin tasks require starting sandal-db with --allow-full-wipe.
+\u2022 If the user requests a database administrative task or full wipe, generate the corresponding query so that the static security guardrails can intercept it and clearly inform the user that --allow-full-wipe is required.`}
+
 \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
 QUERY GENERATION RULES
 \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
 ${dbType === "postgres" ? `\u2022 Target Dialect: PostgreSQL.
-\u2022 Produce valid SQL. For queries with variables, prefer parameterized queries or clean literals when executing directly.
+\u2022 Produce valid SQL. For single queries with parameters, use parameterized queries ($1, $2) with params array, or clean SQL literals.
+\u2022 Multi-table & Complex Operations (Creating tables & Seeding data):
+  - When the user asks to add, generate, mock, or seed data across tables (e.g. "add fake users and their spendings in different tables"):
+    1. If the required tables do not exist in the database schema, automatically generate "CREATE TABLE IF NOT EXISTS" statements for all required tables with appropriate primary keys (e.g. SERIAL PRIMARY KEY or UUID), data types, foreign key references, and timestamps.
+    2. IMPORTANT FOR MANAGED SCHEMAS (e.g. Supabase auth.users): Do NOT insert fake users or mock data directly into managed internal schemas like "auth.users". Instead, create and populate application tables in the "public" schema (e.g. "public.customers" or "public.users", "public.spendings", "public.products", "public.order_items").
+    3. Generate realistic, coherent fake data (realistic names, prices, dates, quantities) with properly matched foreign key relationships between tables.
+    4. Combine all statements into a single, cohesive multi-statement SQL script separated by semicolons (e.g. "CREATE TABLE IF NOT EXISTS ...; CREATE TABLE IF NOT EXISTS ...; INSERT INTO ...; INSERT INTO ...;").
+    5. In multi-statement scripts, embed values directly as clean SQL literals and keep "params": [] so the entire script executes cleanly.
 \u2022 For UPDATE or DELETE queries, ALWAYS include a specific, narrow WHERE clause unless the user explicitly requested modifying all rows.
 \u2022 For index creation, prefer "CREATE INDEX CONCURRENTLY" to avoid write-locking tables.
 \u2022 Return your query formatted in a json object:
   {
     "type": "postgres",
-    "sql": "<the SQL statement>",
+    "sql": "<the SQL statement or multi-statement script>",
     "params": [],
-    "targetTables": ["table1"],
+    "targetTables": ["table1", "table2"],
     "explanation": "<brief summary of what the query does>"
   }` : `\u2022 Target Dialect: MongoDB.
-\u2022 Produce valid MongoDB operations in structured JSON format:
+\u2022 Produce valid MongoDB operations in structured JSON format.
+\u2022 Single-collection operation:
   {
     "type": "mongodb",
     "collection": "<collection_name>",
-    "operation": "find" | "aggregate" | "countDocuments" | "insertOne" | "insertMany" | "updateOne" | "updateMany" | "deleteOne" | "deleteMany" | "createIndex" | "createCollection",
+    "operation": "find" | "aggregate" | "countDocuments" | "insertOne" | "insertMany" | "updateOne" | "updateMany" | "deleteOne" | "deleteMany" | "createIndex" | "createCollection"${allowFullWipe ? ' | "drop" | "dropDatabase" | "command"' : ""},
     "filter": {},
     "update": {},
     "pipeline": [],
     "document": {},
+    "documents": [],
     "options": {},
     "explanation": "<brief summary of what the operation does>"
   }
+\u2022 Multi-collection operations (e.g. adding fake data across multiple collections):
+  {
+    "type": "mongodb",
+    "operations": [
+      { "collection": "users", "operation": "insertMany", "documents": [...] },
+      { "collection": "spendings", "operation": "insertMany", "documents": [...] }
+    ],
+    "explanation": "<brief summary of what the operations do>"
+  }
 \u2022 For UPDATE or DELETE operations, ALWAYS include a specific filter unless the user explicitly requested modifying all documents.
 \u2022 For createIndex, prefer options like {"background": true}.`}
 
@@ -2198,7 +2502,7 @@ var INTENT_CLASSIFICATION_PROMPT = `You are a strict security and intent classif
 Determine whether the following user message is a "database_task" or "out_of_scope".
 
 Definitions:
-- "database_task": The user asks about database schema, tables, collections, fields, running queries, counting rows, inserting/updating/deleting data, creating tables or indexes, filtering, grouping, aggregating, or analyzing database records, or conversational follow-ups directly relating to the database session.
+- "database_task": The user asks about database schema, tables, collections, fields, running queries, counting rows, inserting/updating/deleting data, creating tables or indexes, generating or populating fake/mock/sample data or test fixtures across tables or collections, filtering, grouping, aggregating, analyzing database records, database administration tasks (e.g. database/schema wipes or drops, user/role management like CREATE/DROP USER or ROLE, GRANT/REVOKE permissions, VACUUM, REINDEX, maintenance, killing backend processes/connections, database configuration, or admin commands), or conversational follow-ups directly relating to the database session.
 - "out_of_scope": The user asks for general coding help (e.g., "write a python script to scrape a website", "create a React app", "write a bash script"), general programming questions, creative writing, math tutoring, conversational chat unrelated to the DB, weather, philosophy, history, or anything not acting on the connected database.
 
 Respond with EXACTLY ONE JSON OBJECT and nothing else:
@@ -2224,12 +2528,15 @@ var OBVIOUS_OUT_OF_SCOPE_PATTERNS = [
   /acting\s+as\s+a\s+general\s+chatbot/i
 ];
 var OBVIOUS_DATABASE_PATTERNS = [
-  /^(?:SELECT|INSERT|UPDATE|DELETE|DROP|CREATE|ALTER|TRUNCATE|EXPLAIN|SHOW|DESCRIBE|WITH)\b/i,
+  /^(?:SELECT|INSERT|UPDATE|DELETE|DROP|CREATE|ALTER|TRUNCATE|EXPLAIN|SHOW|DESCRIBE|WITH|GRANT|REVOKE|VACUUM|REINDEX|CHECKPOINT|DISCARD|RESET|LOCK)\b/i,
   /\b(?:table|tables|collection|collections|schema|column|columns|index|indexes|foreign key|primary key)\b/i,
   /\b(?:find|aggregate|count|where|group by|order by|having|limit|join|left join|inner join)\b/i,
   /\b(?:how many (?:users|rows|records|orders|items|products|documents))\b/i,
   /\b(?:database|postgres|mongodb|mongo|pg_)\b/i,
-  /\b(?:query|queries|sql|result|results|rows?|records?)\b/i
+  /\b(?:query|queries|sql|result|results|rows?|records?)\b/i,
+  /\b(?:role|roles|permission|permissions|privilege|privileges|admin|administration|vacuum|reindex|checkpoint|terminate|kill\s+query|backend)\b/i,
+  /\b(?:fake|mock|seed|populate|sample|test)\s+(?:users?|orders?|products?|customers?|data|rows?|records?|documents?|tables?|collections?|spendings?|purchases?)\b/i,
+  /\b(?:add|insert|create|populate|seed|generate)\b.*?\b(?:users?|orders?|products?|customers?|data|rows?|records?|documents?|tables?|collections?|spendings?|purchases?)\b/i
 ];
 function isExplicitNoQuery(input3) {
   const trimmed = input3.trim();
@@ -2318,11 +2625,19 @@ ${trimmed}`;
 function checkStrictWipe(classification, options = {}) {
   const strictMode = options.strictMode !== false;
   const allowFullWipe = options.allowFullWipe === true;
-  if (classification.isFullWipe && strictMode && !allowFullWipe) {
-    return {
-      blocked: true,
-      message: "Operation blocked by --strict mode: full database or all-table drop is prohibited. To allow this, start sandal-db with --allow-full-wipe."
-    };
+  if (strictMode && !allowFullWipe) {
+    if (classification.isFullWipe) {
+      return {
+        blocked: true,
+        message: "Operation blocked by --strict mode: full database or all-table drop is prohibited. To allow this, start sandal-db with --allow-full-wipe."
+      };
+    }
+    if (classification.category === "admin" || classification.isAdmin) {
+      return {
+        blocked: true,
+        message: "Operation blocked by --strict mode: database admin tasks are prohibited. To allow this, start sandal-db with --allow-full-wipe."
+      };
+    }
   }
   return { blocked: false };
 }
@@ -2442,7 +2757,7 @@ function createDatabaseAgent(config) {
         requiresQuery: false
       };
     }
-    const isObviousLiveQuery = /^(?:SELECT|INSERT|UPDATE|DELETE|DROP|CREATE|ALTER|TRUNCATE|GRANT|REVOKE)\b/i.test(userInput) || /^(?:find|search|fetch|get|select|show|display|list|count|delete|update|insert|remove)\s+(?:all\s+|the\s+|every\s+|top\s+\d+\s+)?(?:users?|orders?|products?|customers?|items?|rows?|records?|documents?|accounts?|entries)\b/i.test(userInput) || /\bhow\s+many\s+(?:users|orders|products|items|rows|records|documents|customers|accounts)\b/i.test(userInput);
+    const isObviousLiveQuery = /^(?:SELECT|INSERT|UPDATE|DELETE|DROP|CREATE|ALTER|TRUNCATE|GRANT|REVOKE|VACUUM|REINDEX|CHECKPOINT|DISCARD|LOCK)\b/i.test(userInput) || /\b(?:add|insert|populate|seed|generate|mock|create|make|fill|build|setup|load|import)\s+(?:fake\s+|mock\s+|sample\s+|test\s+|some\s+|new\s+|\d+\s+)?(?:users?|orders?|products?|customers?|items?|rows?|records?|documents?|accounts?|entries|data|tables?|collections?|spendings?|purchases?|transactions?|sales?)\b/i.test(userInput) || /^(?:find|search|fetch|get|select|show|display|list|count|delete|update|insert|remove|add|seed|populate)\s+(?:all\s+|the\s+|every\s+|top\s+\d+\s+)?(?:users?|orders?|products?|customers?|items?|rows?|records?|documents?|accounts?|entries|spendings?|purchases?|transactions?)\b/i.test(userInput) || /\bhow\s+many\s+(?:users|orders|products|items|rows|records|documents|customers|accounts)\b/i.test(userInput) || /\b(?:grant|revoke|vacuum|reindex|checkpoint|kill\s+query|terminate\s+backend|drop\s+database|wipe\s+database|create\s+(?:user|role)|drop\s+(?:user|role)|alter\s+(?:user|role|system|database))\b/i.test(userInput);
     if (isObviousLiveQuery) {
       return {
         ...baseReset,
@@ -2459,7 +2774,8 @@ function createDatabaseAgent(config) {
         requiresQuery: false
       };
     }
-    const isSchemaOrMetaQuestion = /\b(?:schema|database\s+structure)\b/i.test(userInput) || /\b(?:explain|describe|what|tell\s+me\s+about)\b.*?\b(?:tables?|collections?|columns?|indexes?|foreign\s+keys?|schema)\b/i.test(userInput) || /\b(?:what\s+(?:tables|collections|columns)\s+(?:exist|are\s+there|do\s+we\s+have))\b/i.test(userInput) || /\b(?:what\s+was\s+the\s+(?:last|previous)\s+query|why\s+did\s+(?:the\s+last\s+query|it)\s+fail)\b/i.test(userInput);
+    const isMutationOrAction = /\b(?:add|insert|create|populate|seed|generate|mock|make|fill|build|setup|drop|delete|update|alter|truncate|remove)\b/i.test(userInput);
+    const isSchemaOrMetaQuestion = !isMutationOrAction && (/\b(?:what|which)\s+(?:tables|collections|columns|indexes)\s+(?:exist|are\s+there|do\s+we\s+have|are\s+available)\b/i.test(userInput) || /\b(?:show|list|describe|explain|print|display|view)\s+(?:the\s+)?(?:schema|tables?|collections?|columns?|indexes?|foreign\s+keys?|database\s+structure)\b/i.test(userInput) || /\b(?:explain|describe|show|list)\s+what\s+(?:tables|collections|columns|indexes)\b/i.test(userInput) || /\b(?:what\s+is\s+the\s+(?:schema|database\s+structure))\b/i.test(userInput) || /\b(?:what\s+was\s+the\s+(?:last|previous)\s+query|why\s+did\s+(?:the\s+last\s+query|it)\s+fail)\b/i.test(userInput));
     if (isSchemaOrMetaQuestion && (state.schemaSummary || state.messages.length > 0)) {
       return {
         ...baseReset,
@@ -2481,8 +2797,8 @@ Recent Context:
 Rules:
 1. If the user explicitly asks NOT to run a query (e.g., "don't run query", "without querying", "do not execute queries"), requiresQuery MUST be false.
 2. If the user asks to format, summarize, filter, inspect, or calculate based on the previous results or conversation context, requiresQuery MUST be false.
-3. If the user asks about the schema structure, columns, or general knowledge answerable from context, requiresQuery MUST be false.
-4. If the user asks to retrieve fresh records from a table/collection, count rows in the database, modify, insert, delete, or create database objects, requiresQuery MUST be true.
+3. If the user asks purely about the existing schema structure, list of tables/columns, or general knowledge answerable from context, requiresQuery MUST be false.
+4. If the user asks to retrieve fresh records from a table/collection, count rows in the database, modify, insert, delete, create database objects, or generate/populate/seed fake, mock, or sample data (including creating tables for it), requiresQuery MUST be true.
 
 Respond with JSON only:
 {"requiresQuery": boolean, "reason": "<short explanation>"}`;
@@ -2517,10 +2833,11 @@ Respond with JSON only:
     const historyMessages = state.messages.slice(-4);
     const prompt = `Based on this user request: "${state.userInput}"
 And the available database schema:
-${state.schemaSummary}
+${state.schemaSummary || "No schema loaded."}
 
 List the relevant table names (PostgreSQL) or collection names (MongoDB) needed to fulfill the request.
-Respond with a JSON array of string names only, e.g. ["users", "orders"]. Do not include markdown codeblocks or extra text.`;
+Include existing tables as well as any new tables or collections that should be created or populated for this request.
+Respond with a JSON array of string names only, e.g. ["users", "spendings", "products"]. Do not include markdown codeblocks or extra text.`;
     try {
       const response = await model.invoke([
         ...historyMessages,
@@ -2535,7 +2852,9 @@ Respond with a JSON array of string names only, e.g. ["users", "orders"]. Do not
     }
   }
   async function generateQueryNode(state) {
-    const systemPrompt = getSystemPrompt(adapter.type, state.schemaSummary);
+    const systemPrompt = getSystemPrompt(adapter.type, state.schemaSummary, {
+      allowFullWipe: classifierOptions?.allowFullWipe
+    });
     const historyMessages = state.messages.slice(-6);
     const userPrompt = `User request: "${state.userInput}"
 Target entities: ${JSON.stringify(state.targetEntities)}
@@ -2566,7 +2885,7 @@ Do not wrap with markdown or code fences.`;
         rawDisplay: sql
       };
     } else {
-      if (parsed && parsed.collection && parsed.operation) {
+      if (parsed && (parsed.collection && parsed.operation || parsed.operations)) {
         query = {
           collection: parsed.collection,
           operation: parsed.operation,
@@ -2576,6 +2895,7 @@ Do not wrap with markdown or code fences.`;
           document: parsed.document,
           documents: parsed.documents,
           options: parsed.options,
+          operations: parsed.operations,
           rawDisplay: JSON.stringify(parsed, null, 2)
         };
       } else {
@@ -2638,10 +2958,23 @@ Do not wrap with markdown or code fences.`;
       return {};
     }
     const result = await adapter.executeQuery(state.generatedQuery);
-    const isStructuralSuccess = Boolean(state.safety?.isStructural && result.success);
+    const isStructuralSuccess = Boolean(
+      (state.safety?.isStructural || state.safety?.isAdmin || state.safety?.isFullWipe) && result.success
+    );
+    let updatedSchema = state.schema;
+    let updatedSummary = state.schemaSummary;
+    if (isStructuralSuccess) {
+      try {
+        updatedSchema = await adapter.inspectSchema(true);
+        updatedSummary = updatedSchema ? formatSchemaForPrompt(updatedSchema) : state.schemaSummary;
+      } catch {
+      }
+    }
     return {
       queryResult: result,
-      requiresSchemaRefresh: isStructuralSuccess
+      schema: updatedSchema,
+      schemaSummary: updatedSummary,
+      requiresSchemaRefresh: false
     };
   }
   async function analyzeResultsNode(state) {
@@ -2787,8 +3120,7 @@ Guidelines:
 1. Provide a direct, helpful, and accurate natural-language response to the user's request.
 2. If the user asked to do something with previous results (e.g. summarize, format, count, calculate, extract, sort), perform that operation using the PREVIOUS QUERY EXECUTION DETAILS above.
 3. If the user asked to use previous results but NO previous results exist in the session, politely explain that no previous query results are available in this session.
-4. DO NOT output, execute, or propose any new database queries.
-5. Ground your answer strictly in the available schema, history, or previous query results. Never hallucinate data.`;
+4. Ground your answer strictly in the available schema, history, or previous query results. Never hallucinate data.`;
     try {
       const response = await model.invoke([
         ...historyMessages,
@@ -3902,7 +4234,8 @@ Schema for collection: ${collection.name}`));
       `${chalk4.bold("Database:")}      ${chalk4.green(this.adapter.type.toUpperCase())} (${this.adapter.getMaskedUrl()})`,
       `${chalk4.bold("LLM Provider:")}  ${chalk4.blue(this.provider)} [${chalk4.white(this.modelName)}]`,
       `${chalk4.bold("Chat Session:")}  ${chalk4.yellow(this.sessionId)}`,
-      `${chalk4.bold("Strict Mode:")}   ${this.strictMode ? chalk4.green("ON (Full wipes blocked)") : chalk4.yellow("OFF")}`,
+      `${chalk4.bold("Strict Mode:")}   ${this.strictMode ? this.allowFullWipe ? chalk4.yellow("ON (Wipes & admin allowed)") : chalk4.green("ON (Wipes & admin blocked)") : chalk4.yellow("OFF")}`,
+      `${chalk4.bold("Admin Tasks:")}   ${this.allowFullWipe ? chalk4.green("ALLOWED (--allow-full-wipe)") : chalk4.gray("BLOCKED (start with --allow-full-wipe)")}`,
       `${chalk4.bold("Markdown:")}      ${this.renderMarkdown ? chalk4.green("ENABLED") : chalk4.gray("DISABLED")}`,
       "",
       chalk4.gray("Type your natural language request or SQL/Mongo query."),
@@ -3992,7 +4325,7 @@ program.name("sandal-db").description("SANDAL - Safe Agentic Natural-language Da
   true
 ).option("--no-strict", "Disable strict safety mode").option(
   "--allow-full-wipe",
-  "Explicitly allow full database / all-table wipe queries with confirmation",
+  "Explicitly allow full database / all-table wipe queries and db admin tasks with confirmation",
   false
 ).option(
   "--threshold <number>",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sandal-db",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "description": "SANDAL - Safe Agentic Natural-language Database Access Layer. Production-grade agentic database assistant CLI using LangGraph and LLMs (Google Gemini, OpenAI, Anthropic)",
   "type": "module",
   "bin": {