@aigne/afs-sqlite 1.11.0-beta.6 → 1.11.0-beta.7

package/dist/actions/built-in.cjs

@@ -1,3 +1,5 @@
+const require_operators = require('./operators.cjs');
+const require_types = require('./types.cjs');
 let _aigne_sqlite = require("@aigne/sqlite");
 
 //#region src/actions/built-in.ts
@@ -14,6 +16,18 @@ async function execRun(db, query) {
 	await db.run(_aigne_sqlite.sql.raw(query)).execute();
 }
 /**
+* Executes a parameterized SQL query and returns all rows
+*/
+async function execSql(db, sqlQuery) {
+	return db.all(sqlQuery).execute();
+}
+/**
+* Executes a parameterized SQL statement (for INSERT, UPDATE, DELETE)
+*/
+async function runSql(db, sqlQuery) {
+	return { changes: (await db.run(sqlQuery).execute()).rowsAffected };
+}
+/**
 * Registers built-in actions to the registry
 */
 function registerBuiltInActions(registry) {
@@ -129,7 +143,49 @@ function registerBuiltInActions(registry) {
 		}
 	});
 	registry.register({
-		name: "create-table",
+		name: "insert",
+		description: "Insert a new row into the table",
+		rootLevel: false,
+		tableLevel: true,
+		rowLevel: false,
+		inputSchemaGenerator: (schemaCtx) => {
+			if (!schemaCtx.tableSchema) return {
+				type: "object",
+				properties: { data: {
+					type: "object",
+					description: "Row data to insert (column names as keys)",
+					additionalProperties: true
+				} },
+				required: ["data"]
+			};
+			return generateInsertSchema(schemaCtx.tableSchema);
+		},
+		handler: async (ctx, params) => {
+			const data = params.data;
+			if (!data || Object.keys(data).length === 0) throw new Error("Insert data is required");
+			if (!await ctx.schemaService.getSchema(ctx.table)) throw new Error(`Table '${ctx.table}' not found`);
+			const columns = Object.keys(data);
+			const values = columns.map((col) => formatValueForSQL(data[col]));
+			const insertSQL = `INSERT INTO "${ctx.table}" (${columns.map((c) => `"${c}"`).join(", ")}) VALUES (${values.join(", ")})`;
+			try {
+				await execRun(ctx.db, insertSQL);
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				throw new Error(`Insert failed: ${message}`);
+			}
+			const newId = (await execAll(ctx.db, "SELECT last_insert_rowid() as id"))[0]?.id;
+			return {
+				success: true,
+				data: {
+					id: newId,
+					...data
+				},
+				message: `Row inserted successfully with id ${newId}`
+			};
+		}
+	});
+	registry.register({
+		name: "create_table",
 		description: "Create a new table in the database",
 		rootLevel: true,
 		tableLevel: false,
@@ -387,44 +443,758 @@ function registerBuiltInActions(registry) {
 		}
 	});
 	registry.register({
-		name: "insert",
-		description: "Insert a new row into the table",
+		name: "drop_table",
+		description: "Drop a table from the database",
+		rootLevel: true,
+		tableLevel: false,
+		rowLevel: false,
+		inputSchema: {
+			type: "object",
+			properties: {
+				name: {
+					type: "string",
+					description: "Table name to drop"
+				},
+				ifExists: {
+					type: "boolean",
+					default: false,
+					description: "Don't error if table doesn't exist"
+				}
+			},
+			required: ["name"]
+		},
+		handler: async (ctx, params) => {
+			const tableName = params.name;
+			const ifExists = params.ifExists;
+			if (!tableName) return require_types.errorResult(require_types.SQLiteActionErrorCode.INVALID_INPUT, "Table name is required");
+			const exists = await ctx.schemaService.hasTable(tableName);
+			if (!exists && !ifExists) return require_types.errorResult(require_types.SQLiteActionErrorCode.NOT_FOUND, `Table '${tableName}' does not exist`);
+			if (exists) {
+				const ifExistsClause = ifExists ? "IF EXISTS " : "";
+				await execRun(ctx.db, `DROP TABLE ${ifExistsClause}"${tableName}"`);
+			}
+			return {
+				success: true,
+				data: { tableName },
+				message: `Table '${tableName}' dropped successfully`
+			};
+		}
+	});
+	registry.register({
+		name: "rename_table",
+		description: "Rename a table in the database",
+		rootLevel: true,
+		tableLevel: false,
+		rowLevel: false,
+		inputSchema: {
+			type: "object",
+			properties: {
+				oldName: {
+					type: "string",
+					description: "Current table name"
+				},
+				newName: {
+					type: "string",
+					description: "New table name"
+				}
+			},
+			required: ["oldName", "newName"]
+		},
+		handler: async (ctx, params) => {
+			const oldName = params.oldName;
+			const newName = params.newName;
+			if (!oldName || !newName) return require_types.errorResult(require_types.SQLiteActionErrorCode.INVALID_INPUT, "Both oldName and newName are required");
+			if (!/^[a-zA-Z][a-zA-Z0-9_]*$/.test(newName)) return require_types.errorResult(require_types.SQLiteActionErrorCode.INVALID_INPUT, "New table name must start with a letter and contain only alphanumeric characters and underscores");
+			if (!await ctx.schemaService.hasTable(oldName)) return require_types.errorResult(require_types.SQLiteActionErrorCode.NOT_FOUND, `Table '${oldName}' does not exist`);
+			if (await ctx.schemaService.hasTable(newName)) return require_types.errorResult(require_types.SQLiteActionErrorCode.CONSTRAINT_VIOLATION, `Table '${newName}' already exists`);
+			await execRun(ctx.db, `ALTER TABLE "${oldName}" RENAME TO "${newName}"`);
+			return {
+				success: true,
+				data: {
+					oldName,
+					newName
+				},
+				message: `Table renamed from '${oldName}' to '${newName}'`
+			};
+		}
+	});
+	registry.register({
+		name: "add_column",
+		description: "Add a new column to the table",
+		rootLevel: false,
+		tableLevel: true,
+		rowLevel: false,
+		inputSchema: {
+			type: "object",
+			properties: {
+				name: {
+					type: "string",
+					description: "Column name"
+				},
+				type: {
+					type: "string",
+					enum: [
+						"INTEGER",
+						"TEXT",
+						"REAL",
+						"BLOB",
+						"NUMERIC"
+					],
+					description: "Column type"
+				},
+				nullable: {
+					type: "boolean",
+					default: true,
+					description: "Whether the column allows NULL values"
+				},
+				defaultValue: {
+					oneOf: [
+						{ type: "string" },
+						{ type: "number" },
+						{ type: "boolean" },
+						{ type: "null" }
+					],
+					description: "Default value for the column"
+				}
+			},
+			required: ["name", "type"]
+		},
+		handler: async (ctx, params) => {
+			const colName = params.name;
+			const colType = params.type;
+			const nullable = params.nullable !== false;
+			const defaultValue = params.defaultValue;
+			if (!colName || !colType) return require_types.errorResult(require_types.SQLiteActionErrorCode.INVALID_INPUT, "Column name and type are required");
+			let columnDef = `"${colName}" ${colType.toUpperCase()}`;
+			if (!nullable) columnDef += " NOT NULL";
+			if (defaultValue !== void 0) columnDef += ` DEFAULT ${formatValueForSQL(defaultValue)}`;
+			try {
+				await execRun(ctx.db, `ALTER TABLE "${ctx.table}" ADD COLUMN ${columnDef}`);
+			} catch (error) {
+				if ((error instanceof Error ? error.message : String(error)).includes("duplicate column name")) return require_types.errorResult(require_types.SQLiteActionErrorCode.CONSTRAINT_VIOLATION, `Column '${colName}' already exists`);
+				throw error;
+			}
+			return {
+				success: true,
+				data: {
+					table: ctx.table,
+					column: colName,
+					type: colType
+				},
+				message: `Column '${colName}' added to table '${ctx.table}'`
+			};
+		}
+	});
+	registry.register({
+		name: "rename_column",
+		description: "Rename a column in the table",
+		rootLevel: false,
+		tableLevel: true,
+		rowLevel: false,
+		inputSchema: {
+			type: "object",
+			properties: {
+				oldName: {
+					type: "string",
+					description: "Current column name"
+				},
+				newName: {
+					type: "string",
+					description: "New column name"
+				}
+			},
+			required: ["oldName", "newName"]
+		},
+		handler: async (ctx, params) => {
+			const oldName = params.oldName;
+			const newName = params.newName;
+			if (!oldName || !newName) return require_types.errorResult(require_types.SQLiteActionErrorCode.INVALID_INPUT, "Both oldName and newName are required");
+			const schema = await ctx.schemaService.getSchema(ctx.table);
+			if (!schema) return require_types.errorResult(require_types.SQLiteActionErrorCode.NOT_FOUND, `Table '${ctx.table}' not found`);
+			if (!schema.columns.some((c) => c.name === oldName)) return require_types.errorResult(require_types.SQLiteActionErrorCode.NOT_FOUND, `Column '${oldName}' not found in table '${ctx.table}'`);
+			await execRun(ctx.db, `ALTER TABLE "${ctx.table}" RENAME COLUMN "${oldName}" TO "${newName}"`);
+			return {
+				success: true,
+				data: {
+					table: ctx.table,
+					oldName,
+					newName
+				},
+				message: `Column renamed from '${oldName}' to '${newName}'`
+			};
+		}
+	});
+	registry.register({
+		name: "drop_column",
+		description: "Drop a column from the table",
 		rootLevel: false,
 		tableLevel: true,
 		rowLevel: false,
+		inputSchema: {
+			type: "object",
+			properties: { name: {
+				type: "string",
+				description: "Column name to drop"
+			} },
+			required: ["name"]
+		},
+		handler: async (ctx, params) => {
+			const colName = params.name;
+			if (!colName) return require_types.errorResult(require_types.SQLiteActionErrorCode.INVALID_INPUT, "Column name is required");
+			const schema = await ctx.schemaService.getSchema(ctx.table);
+			if (!schema) return require_types.errorResult(require_types.SQLiteActionErrorCode.NOT_FOUND, `Table '${ctx.table}' not found`);
+			if (!schema.columns.some((c) => c.name === colName)) return require_types.errorResult(require_types.SQLiteActionErrorCode.NOT_FOUND, `Column '${colName}' not found in table '${ctx.table}'`);
+			await execRun(ctx.db, `ALTER TABLE "${ctx.table}" DROP COLUMN "${colName}"`);
+			return {
+				success: true,
+				data: {
+					table: ctx.table,
+					column: colName
+				},
+				message: `Column '${colName}' dropped from table '${ctx.table}'`
+			};
+		}
+	});
+	registry.register({
+		name: "create_index",
+		description: "Create an index on the table",
+		rootLevel: false,
+		tableLevel: true,
+		rowLevel: false,
+		inputSchema: {
+			type: "object",
+			properties: {
+				name: {
+					type: "string",
+					description: "Index name"
+				},
+				columns: {
+					type: "array",
+					items: { type: "string" },
+					minItems: 1,
+					description: "Columns to index (supports compound indexes)"
+				},
+				unique: {
+					type: "boolean",
+					default: false,
+					description: "Whether the index is unique"
+				},
+				ifNotExists: {
+					type: "boolean",
+					default: false,
+					description: "Don't error if index already exists"
+				}
+			},
+			required: ["name", "columns"]
+		},
+		handler: async (ctx, params) => {
+			const indexName = params.name;
+			const columns = params.columns;
+			const unique = params.unique;
+			const ifNotExists = params.ifNotExists;
+			if (!indexName || !columns || columns.length === 0) return require_types.errorResult(require_types.SQLiteActionErrorCode.INVALID_INPUT, "Index name and columns are required");
+			const uniqueClause = unique ? "UNIQUE " : "";
+			const ifNotExistsClause = ifNotExists ? "IF NOT EXISTS " : "";
+			const columnsClause = columns.map((c) => `"${c}"`).join(", ");
+			await execRun(ctx.db, `CREATE ${uniqueClause}INDEX ${ifNotExistsClause}"${indexName}" ON "${ctx.table}" (${columnsClause})`);
+			return {
+				success: true,
+				data: {
+					indexName,
+					table: ctx.table,
+					columns,
+					unique: !!unique
+				},
+				message: `Index '${indexName}' created on table '${ctx.table}'`
+			};
+		}
+	});
+	registry.register({
+		name: "drop_index",
+		description: "Drop an index from the table",
+		rootLevel: false,
+		tableLevel: true,
+		rowLevel: false,
+		inputSchema: {
+			type: "object",
+			properties: {
+				name: {
+					type: "string",
+					description: "Index name to drop"
+				},
+				ifExists: {
+					type: "boolean",
+					default: false,
+					description: "Don't error if index doesn't exist"
+				}
+			},
+			required: ["name"]
+		},
+		handler: async (ctx, params) => {
+			const indexName = params.name;
+			const ifExists = params.ifExists;
+			if (!indexName) return require_types.errorResult(require_types.SQLiteActionErrorCode.INVALID_INPUT, "Index name is required");
+			const ifExistsClause = ifExists ? "IF EXISTS " : "";
+			await execRun(ctx.db, `DROP INDEX ${ifExistsClause}"${indexName}"`);
+			return {
+				success: true,
+				data: { indexName },
+				message: `Index '${indexName}' dropped`
+			};
+		}
+	});
+	registry.register({
+		name: "update",
+		description: "Update this row",
+		rootLevel: false,
+		tableLevel: false,
+		rowLevel: true,
 		inputSchemaGenerator: (schemaCtx) => {
 			if (!schemaCtx.tableSchema) return {
 				type: "object",
 				properties: { data: {
 					type: "object",
-					description: "Row data to insert (column names as keys)",
+					description: "Fields to update",
 					additionalProperties: true
 				} },
 				required: ["data"]
 			};
-			return generateInsertSchema(schemaCtx.tableSchema);
+			return generateUpdateSchema(schemaCtx.tableSchema);
 		},
 		handler: async (ctx, params) => {
 			const data = params.data;
-			if (!data || Object.keys(data).length === 0) throw new Error("Insert data is required");
-			if (!await ctx.schemaService.getSchema(ctx.table)) throw new Error(`Table '${ctx.table}' not found`);
-			const columns = Object.keys(data);
-			const values = columns.map((col) => formatValueForSQL(data[col]));
-			const insertSQL = `INSERT INTO "${ctx.table}" (${columns.map((c) => `"${c}"`).join(", ")}) VALUES (${values.join(", ")})`;
+			if (!data || Object.keys(data).length === 0) return require_types.errorResult(require_types.SQLiteActionErrorCode.INVALID_INPUT, "Update data is required");
+			if (!ctx.pk) return require_types.errorResult(require_types.SQLiteActionErrorCode.INVALID_INPUT, "Primary key is required for row-level update");
+			const schema = await ctx.schemaService.getSchema(ctx.table);
+			if (!schema) return require_types.errorResult(require_types.SQLiteActionErrorCode.NOT_FOUND, `Table '${ctx.table}' not found`);
+			const pkColumn = schema.primaryKey[0] ?? "rowid";
+			const setClauses = Object.entries(data).map(([col, val]) => `"${col}" = ${formatValueForSQL(val)}`).join(", ");
+			const updateSQL = `UPDATE "${ctx.table}" SET ${setClauses} WHERE "${pkColumn}" = ${formatValueForSQL(ctx.pk)}`;
 			try {
-				await execRun(ctx.db, insertSQL);
+				await execRun(ctx.db, updateSQL);
 			} catch (error) {
 				const message = error instanceof Error ? error.message : String(error);
-				throw new Error(`Insert failed: ${message}`);
+				if (message.includes("UNIQUE constraint failed")) return require_types.errorResult(require_types.SQLiteActionErrorCode.CONSTRAINT_VIOLATION, `Unique constraint violation: ${message}`);
+				throw error;
 			}
-			const newId = (await execAll(ctx.db, "SELECT last_insert_rowid() as id"))[0]?.id;
+			return {
+				success: true,
+				data: (await execAll(ctx.db, `SELECT * FROM "${ctx.table}" WHERE "${pkColumn}" = ${formatValueForSQL(ctx.pk)}`))[0],
+				message: "Row updated successfully"
+			};
+		}
+	});
+	registry.register({
+		name: "delete",
+		description: "Delete this row",
+		rootLevel: false,
+		tableLevel: false,
+		rowLevel: true,
+		inputSchema: {
+			type: "object",
+			properties: {},
+			description: "Delete the current row"
+		},
+		handler: async (ctx) => {
+			if (!ctx.pk) return require_types.errorResult(require_types.SQLiteActionErrorCode.INVALID_INPUT, "Primary key is required for row-level delete");
+			const schema = await ctx.schemaService.getSchema(ctx.table);
+			if (!schema) return require_types.errorResult(require_types.SQLiteActionErrorCode.NOT_FOUND, `Table '${ctx.table}' not found`);
+			const pkColumn = schema.primaryKey[0] ?? "rowid";
+			await execRun(ctx.db, `DELETE FROM "${ctx.table}" WHERE "${pkColumn}" = ${formatValueForSQL(ctx.pk)}`);
+			return {
+				success: true,
+				data: { pk: ctx.pk },
+				message: "Row deleted successfully"
+			};
+		}
+	});
+	registry.register({
+		name: "query",
+		description: "Query rows with conditions, ordering, and pagination",
+		rootLevel: false,
+		tableLevel: true,
+		rowLevel: false,
+		inputSchema: {
+			type: "object",
+			properties: {
+				where: {
+					type: "object",
+					description: "Query conditions (MongoDB-style operators)"
+				},
+				orderBy: {
+					type: "array",
+					items: {
+						type: "object",
+						properties: {
+							column: { type: "string" },
+							direction: {
+								type: "string",
+								enum: ["asc", "desc"],
+								default: "asc"
+							}
+						},
+						required: ["column"]
+					},
+					description: "Sort order"
+				},
+				limit: {
+					type: "integer",
+					minimum: 1,
+					description: "Maximum rows to return"
+				},
+				offset: {
+					type: "integer",
+					minimum: 0,
+					description: "Number of rows to skip"
+				}
+			}
+		},
+		handler: async (ctx, params) => {
+			const where = params.where;
+			const orderBy = params.orderBy;
+			const limit = params.limit;
+			const offset = params.offset;
+			let querySQL = _aigne_sqlite.sql`SELECT * FROM ${_aigne_sqlite.sql.identifier(ctx.table)}`;
+			querySQL = _aigne_sqlite.sql`${querySQL}${require_operators.buildWhereClause(where)}`;
+			if (orderBy && orderBy.length > 0) {
+				const orderClauses = orderBy.map((o) => {
+					const dir = o.direction?.toUpperCase() === "DESC" ? _aigne_sqlite.sql` DESC` : _aigne_sqlite.sql` ASC`;
+					return _aigne_sqlite.sql`${_aigne_sqlite.sql.identifier(o.column)}${dir}`;
+				});
+				querySQL = _aigne_sqlite.sql`${querySQL} ORDER BY ${_aigne_sqlite.sql.join(orderClauses, _aigne_sqlite.sql`, `)}`;
+			}
+			if (limit !== void 0) querySQL = _aigne_sqlite.sql`${querySQL} LIMIT ${limit}`;
+			if (offset !== void 0) querySQL = _aigne_sqlite.sql`${querySQL} OFFSET ${offset}`;
+			const rows = await execSql(ctx.db, querySQL);
 			return {
 				success: true,
 				data: {
-					id: newId,
-					...data
+					rows,
+					count: rows.length
+				}
+			};
+		}
+	});
+	registry.register({
+		name: "update_where",
+		description: "Update rows matching conditions",
+		rootLevel: false,
+		tableLevel: true,
+		rowLevel: false,
+		inputSchema: {
+			type: "object",
+			properties: {
+				where: {
+					type: "object",
+					description: "Update conditions (MongoDB-style operators)"
 				},
-				message: `Row inserted successfully with id ${newId}`
+				data: {
+					type: "object",
+					description: "Fields to update"
+				}
+			},
+			required: ["where", "data"]
+		},
+		handler: async (ctx, params) => {
+			const where = params.where;
+			const data = params.data;
+			if (!where || Object.keys(where).length === 0) return require_types.errorResult(require_types.SQLiteActionErrorCode.INVALID_INPUT, "Where clause is required for update_where");
+			if (!data || Object.keys(data).length === 0) return require_types.errorResult(require_types.SQLiteActionErrorCode.INVALID_INPUT, "Update data is required");
+			const setClauses = Object.entries(data).map(([col, val]) => _aigne_sqlite.sql`${_aigne_sqlite.sql.identifier(col)} = ${val}`);
+			const updateSQL = _aigne_sqlite.sql`UPDATE ${_aigne_sqlite.sql.identifier(ctx.table)} SET ${_aigne_sqlite.sql.join(setClauses, _aigne_sqlite.sql`, `)}${require_operators.buildWhereClause(where)}`;
+			const result = await runSql(ctx.db, updateSQL);
+			return {
+				success: true,
+				data: { affectedRows: result.changes },
+				message: `${result.changes} row(s) updated`
+			};
+		}
+	});
+	registry.register({
+		name: "delete_where",
+		description: "Delete rows matching conditions",
+		rootLevel: false,
+		tableLevel: true,
+		rowLevel: false,
+		inputSchema: {
+			type: "object",
+			properties: { where: {
+				type: "object",
+				description: "Delete conditions (MongoDB-style operators)"
+			} },
+			required: ["where"]
+		},
+		handler: async (ctx, params) => {
+			const where = params.where;
+			if (!where || Object.keys(where).length === 0) return require_types.errorResult(require_types.SQLiteActionErrorCode.INVALID_INPUT, "Where clause is required for delete_where");
+			const deleteSQL = _aigne_sqlite.sql`DELETE FROM ${_aigne_sqlite.sql.identifier(ctx.table)}${require_operators.buildWhereClause(where)}`;
+			const result = await runSql(ctx.db, deleteSQL);
+			return {
+				success: true,
+				data: { affectedRows: result.changes },
+				message: `${result.changes} row(s) deleted`
+			};
+		}
+	});
+	registry.register({
+		name: "bulk_insert",
+		description: "Insert multiple rows at once",
+		rootLevel: false,
+		tableLevel: true,
+		rowLevel: false,
+		inputSchema: {
+			type: "object",
+			properties: { rows: {
+				type: "array",
+				items: { type: "object" },
+				minItems: 1,
+				description: "Array of row data to insert"
+			} },
+			required: ["rows"]
+		},
+		handler: async (ctx, params) => {
+			const rows = params.rows;
+			if (!rows || rows.length === 0) return require_types.errorResult(require_types.SQLiteActionErrorCode.INVALID_INPUT, "At least one row is required");
+			const columns = Object.keys(rows[0]);
+			const columnsList = columns.map((c) => `"${c}"`).join(", ");
+			const insertedIds = [];
+			for (const row of rows) {
+				const values = columns.map((col) => formatValueForSQL(row[col]));
+				const insertSQL = `INSERT INTO "${ctx.table}" (${columnsList}) VALUES (${values.join(", ")})`;
+				try {
+					await execRun(ctx.db, insertSQL);
+					const lastIdResult = await execAll(ctx.db, "SELECT last_insert_rowid() as id");
+					insertedIds.push(lastIdResult[0]?.id ?? 0);
+				} catch (error) {
+					const message = error instanceof Error ? error.message : String(error);
+					return require_types.errorResult(require_types.SQLiteActionErrorCode.CONSTRAINT_VIOLATION, `Insert failed at row ${insertedIds.length}: ${message}`, {
+						insertedCount: insertedIds.length,
+						insertedIds
+					});
+				}
+			}
+			return {
+				success: true,
+				data: {
+					insertedCount: rows.length,
+					insertedIds
+				},
+				message: `${rows.length} row(s) inserted`
+			};
+		}
+	});
+	registry.register({
+		name: "pragma",
+		description: "Execute a PRAGMA command (whitelist-restricted)",
+		rootLevel: true,
+		tableLevel: false,
+		rowLevel: false,
+		inputSchema: {
+			type: "object",
+			properties: {
+				command: {
+					type: "string",
+					enum: [
+						"table_info",
+						"table_list",
+						"index_list",
+						"index_info",
+						"foreign_key_list",
+						"database_list",
+						"collation_list",
+						"journal_mode",
+						"synchronous",
+						"cache_size",
+						"page_size",
+						"encoding",
+						"auto_vacuum",
+						"integrity_check",
+						"quick_check"
+					],
+					description: "PRAGMA command to execute"
+				},
+				argument: {
+					type: "string",
+					description: "Argument for the command (e.g., table name)"
+				},
+				value: {
+					oneOf: [{ type: "string" }, { type: "number" }],
+					description: "Value for writable PRAGMAs"
+				}
+			},
+			required: ["command"]
+		},
+		handler: async (ctx, params) => {
+			const command = params.command;
+			const argument = params.argument;
+			const value = params.value;
+			const allowedCommands = [
+				"table_info",
+				"table_list",
+				"index_list",
+				"index_info",
+				"foreign_key_list",
+				"database_list",
+				"collation_list",
+				"journal_mode",
+				"synchronous",
+				"cache_size",
+				"page_size",
+				"encoding",
+				"auto_vacuum",
+				"integrity_check",
+				"quick_check"
+			];
+			if (!allowedCommands.includes(command)) return require_types.errorResult(require_types.SQLiteActionErrorCode.INVALID_INPUT, `PRAGMA command '${command}' is not allowed. Allowed: ${allowedCommands.join(", ")}`);
+			let pragmaSQL = `PRAGMA ${command}`;
+			if (argument) pragmaSQL += `("${argument}")`;
+			if (value !== void 0) pragmaSQL += ` = ${typeof value === "string" ? `'${value}'` : value}`;
+			const result = await execAll(ctx.db, pragmaSQL);
+			return {
+				success: true,
+				data: result.length === 1 && Object.keys(result[0]).length === 1 ? Object.values(result[0])[0] : result
+			};
+		}
+	});
+	registry.register({
+		name: "import",
+		description: "Import data into table from JSON or CSV format",
+		tableLevel: true,
+		rowLevel: false,
+		inputSchema: {
+			type: "object",
+			properties: {
+				format: {
+					type: "string",
+					enum: ["json", "csv"],
+					description: "Data format (json or csv)"
+				},
+				data: {
+					type: "string",
+					description: "The data to import (JSON array string or CSV string)"
+				},
+				onConflict: {
+					type: "string",
+					enum: [
+						"abort",
+						"ignore",
+						"replace"
+					],
+					default: "abort",
+					description: "Conflict resolution strategy"
+				},
+				delimiter: {
+					type: "string",
+					default: ",",
+					description: "CSV delimiter character"
+				},
+				header: {
+					type: "boolean",
+					default: true,
+					description: "Whether CSV has a header row"
+				}
+			},
+			required: ["format", "data"]
+		},
+		handler: async (ctx, params) => {
+			const format = params.format;
+			const data = params.data;
+			const onConflict = params.onConflict ?? "abort";
+			const delimiter = params.delimiter ?? ",";
+			const hasHeader = params.header !== false;
+			if (!["json", "csv"].includes(format)) return require_types.errorResult(require_types.SQLiteActionErrorCode.INVALID_INPUT, `Unsupported import format: ${format}. Supported: json, csv`);
+			const schema = await ctx.schemaService.getSchema(ctx.table);
+			if (!schema) return require_types.errorResult(require_types.SQLiteActionErrorCode.NOT_FOUND, `Table not found: ${ctx.table}`);
+			let rows;
+			try {
+				if (format === "json") {
+					const parsed = JSON.parse(data);
+					if (!Array.isArray(parsed)) return require_types.errorResult(require_types.SQLiteActionErrorCode.INVALID_INPUT, "JSON data must be an array of objects");
+					rows = parsed;
+				} else rows = parseCSV(data, delimiter, hasHeader, schema);
+			} catch (error) {
+				return require_types.errorResult(require_types.SQLiteActionErrorCode.INVALID_INPUT, `Failed to parse ${format} data: ${error instanceof Error ? error.message : "unknown error"}`);
+			}
+			if (rows.length === 0) return {
+				success: true,
+				data: {
+					imported: 0,
+					skipped: 0
+				}
+			};
+			let conflictClause = "";
+			if (onConflict === "ignore") conflictClause = " OR IGNORE";
+			else if (onConflict === "replace") conflictClause = " OR REPLACE";
+			const columnNames = schema.columns.map((c) => c.name);
+			let imported = 0;
+			let skipped = 0;
+			try {
+				await execRun(ctx.db, "BEGIN TRANSACTION");
+				for (const row of rows) {
+					const usedColumns = [];
+					const values = [];
+					for (const colName of columnNames) if (colName in row) {
+						usedColumns.push(colName);
+						values.push(formatValueForSQL(row[colName]));
+					}
+					if (usedColumns.length === 0) continue;
+					const insertSQL = `INSERT${conflictClause} INTO "${ctx.table}" (${usedColumns.map((c) => `"${c}"`).join(", ")}) VALUES (${values.join(", ")})`;
+					try {
+						await execAll(ctx.db, insertSQL);
+						if (((await execAll(ctx.db, "SELECT changes() as changes"))[0]?.changes ?? 0) > 0) imported++;
+						else skipped++;
+					} catch (error) {
+						if (onConflict === "abort") {
+							await execRun(ctx.db, "ROLLBACK");
+							return require_types.errorResult(require_types.SQLiteActionErrorCode.CONSTRAINT_VIOLATION, `Import aborted: ${error instanceof Error ? error.message : "constraint violation"}`);
+						}
+						skipped++;
+					}
+				}
+				await execRun(ctx.db, "COMMIT");
+				return {
+					success: true,
+					data: {
+						imported,
+						skipped
+					}
+				};
+			} catch (error) {
+				try {
+					await execRun(ctx.db, "ROLLBACK");
+				} catch {}
+				return require_types.errorResult(require_types.SQLiteActionErrorCode.INVALID_INPUT, `Import failed: ${error instanceof Error ? error.message : "unknown error"}`);
+			}
+		}
+	});
+	registry.register({
+		name: "vacuum",
+		description: "Compact the database file and reclaim unused space",
+		rootLevel: true,
+		tableLevel: false,
+		rowLevel: false,
+		inputSchema: {
+			type: "object",
+			properties: {},
+			additionalProperties: false
+		},
+		handler: async (ctx) => {
+			const pageCountBefore = await execAll(ctx.db, "PRAGMA page_count");
+			const pageSize = (await execAll(ctx.db, "PRAGMA page_size"))[0]?.page_size ?? 4096;
+			const sizeBefore = (pageCountBefore[0]?.page_count ?? 0) * pageSize;
+			try {
+				await execRun(ctx.db, "VACUUM");
+			} catch (error) {
+				return require_types.errorResult(require_types.SQLiteActionErrorCode.INVALID_INPUT, `Vacuum failed: ${error instanceof Error ? error.message : "unknown error"}`);
+			}
+			const sizeAfter = ((await execAll(ctx.db, "PRAGMA page_count"))[0]?.page_count ?? 0) * pageSize;
+			return {
+				success: true,
+				data: {
+					sizeBefore,
+					sizeAfter,
+					freedBytes: sizeBefore - sizeAfter
+				}
 			};
 		}
 	});
@@ -441,6 +1211,67 @@ function formatValueForSQL(value) {
 	return `'${String(value).replace(/'/g, "''")}'`;
 }
 /**
+* Parse a CSV string into an array of row objects.
+*/
+function parseCSV(data, delimiter, hasHeader, schema) {
+	const lines = data.split("\n").filter((line) => line.trim() !== "");
+	if (lines.length === 0) return [];
+	let headers;
+	let startIndex;
+	if (hasHeader) {
+		if (lines.length < 1) return [];
+		headers = parseCsvLine(lines[0], delimiter);
+		startIndex = 1;
+	} else {
+		headers = schema.columns.map((c) => c.name);
+		startIndex = 0;
+	}
+	const rows = [];
+	for (let i = startIndex; i < lines.length; i++) {
+		const values = parseCsvLine(lines[i], delimiter);
+		const row = {};
+		for (let j = 0; j < headers.length && j < values.length; j++) row[headers[j]] = values[j];
+		rows.push(row);
+	}
+	return rows;
+}
+/**
+* Parse a single CSV line, handling quoted fields.
+*/
+function parseCsvLine(line, delimiter) {
+	const fields = [];
+	let current = "";
+	let inQuotes = false;
+	let i = 0;
+	while (i < line.length) {
+		const char = line[i];
+		if (inQuotes) if (char === "\"") if (i + 1 < line.length && line[i + 1] === "\"") {
+			current += "\"";
+			i += 2;
+		} else {
+			inQuotes = false;
+			i++;
+		}
+		else {
+			current += char;
+			i++;
+		}
+		else if (char === "\"") {
+			inQuotes = true;
+			i++;
+		} else if (line.substring(i, i + delimiter.length) === delimiter) {
+			fields.push(current);
+			current = "";
+			i += delimiter.length;
+		} else {
+			current += char;
+			i++;
+		}
+	}
+	fields.push(current);
+	return fields;
+}
+/**
 * Maps SQLite column type to JSON Schema type
 */
 function sqliteTypeToJsonSchema(sqliteType) {
@@ -530,6 +1361,29 @@ function generateDuplicateSchema(tableSchema) {
 		"x-copied-columns": copiedColumns
 	};
 }
+/**
+* Generates JSON Schema for update action based on table schema
+*/
+function generateUpdateSchema(tableSchema) {
+	const properties = {};
+	const pkColumn = tableSchema.primaryKey[0] ?? "rowid";
+	for (const col of tableSchema.columns) {
+		if (col.name === pkColumn) continue;
+		const typeInfo = sqliteTypeToJsonSchema(col.type);
+		properties[col.name] = typeInfo;
+	}
+	return {
+		type: "object",
+		description: `Update fields in "${tableSchema.name}" table`,
+		properties: { data: {
+			type: "object",
+			description: "Fields to update",
+			properties,
+			additionalProperties: false
+		} },
+		required: ["data"]
+	};
+}
 
 //#endregion
 exports.registerBuiltInActions = registerBuiltInActions;