@aigne/afs-sqlite 1.11.0-beta → 1.11.0-beta.10

package/dist/actions/built-in.cjs

@@ -0,0 +1,1389 @@
+const require_operators = require('./operators.cjs');
+const require_types = require('./types.cjs');
+let _aigne_sqlite = require("@aigne/sqlite");
+
+//#region src/actions/built-in.ts
+/**
+* Executes a raw SQL query and returns all rows
+*/
+async function execAll(db, query) {
+	return db.all(_aigne_sqlite.sql.raw(query)).execute();
+}
+/**
+* Executes a raw SQL query (for INSERT, UPDATE, DELETE)
+*/
+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) {
+	registry.register({
+		name: "export",
+		description: "Export table data in specified format (json, csv)",
+		tableLevel: true,
+		rowLevel: false,
+		inputSchema: {
+			type: "object",
+			properties: { format: {
+				type: "string",
+				enum: ["json", "csv"],
+				default: "json"
+			} }
+		},
+		handler: async (ctx, params) => {
+			const format = params.format ?? "json";
+			return {
+				success: true,
+				data: await ctx.module.exportTable(ctx.table, format)
+			};
+		}
+	});
+	registry.register({
+		name: "count",
+		description: "Get the total row count for this table",
+		tableLevel: true,
+		rowLevel: false,
+		handler: async (ctx) => {
+			return {
+				success: true,
+				data: { count: (await execAll(ctx.db, `SELECT COUNT(*) as count FROM "${ctx.table}"`))[0]?.count ?? 0 }
+			};
+		}
+	});
+	registry.register({
+		name: "duplicate",
+		description: "Create a copy of this row",
+		tableLevel: false,
+		rowLevel: true,
+		inputSchemaGenerator: (schemaCtx) => {
+			if (!schemaCtx.tableSchema) return {
+				type: "object",
+				properties: {},
+				additionalProperties: false
+			};
+			return generateDuplicateSchema(schemaCtx.tableSchema);
+		},
+		handler: async (ctx) => {
+			if (!ctx.row) return {
+				success: false,
+				message: "Row data not available"
+			};
+			const schema = await ctx.schemaService.getSchema(ctx.table);
+			if (!schema) return {
+				success: false,
+				message: `Table '${ctx.table}' not found`
+			};
+			const pkColumn = schema.primaryKey[0] ?? "rowid";
+			const rowCopy = { ...ctx.row };
+			delete rowCopy[pkColumn];
+			delete rowCopy.rowid;
+			const columns = Object.keys(rowCopy);
+			const values = columns.map((col) => formatValueForSQL(rowCopy[col]));
+			await execRun(ctx.db, `INSERT INTO "${ctx.table}" (${columns.map((c) => `"${c}"`).join(", ")}) VALUES (${values.join(", ")})`);
+			return {
+				success: true,
+				data: { newId: (await execAll(ctx.db, "SELECT last_insert_rowid() as id"))[0]?.id },
+				message: "Row duplicated successfully"
+			};
+		}
+	});
+	registry.register({
+		name: "validate",
+		description: "Validate row data against schema constraints",
+		tableLevel: false,
+		rowLevel: true,
+		inputSchemaGenerator: (schemaCtx) => {
+			if (!schemaCtx.tableSchema) return {
+				type: "object",
+				properties: {},
+				additionalProperties: false
+			};
+			return generateValidateSchema(schemaCtx.tableSchema);
+		},
+		handler: async (ctx) => {
+			if (!ctx.row) return {
+				success: false,
+				message: "Row data not available"
+			};
+			const schema = await ctx.schemaService.getSchema(ctx.table);
+			if (!schema) return {
+				success: false,
+				message: `Table '${ctx.table}' not found`
+			};
+			const errors = [];
+			for (const col of schema.columns) if (col.notnull && (ctx.row[col.name] === null || ctx.row[col.name] === void 0)) errors.push(`Column '${col.name}' cannot be null`);
+			for (const fk of schema.foreignKeys) {
+				const value = ctx.row[fk.from];
+				if (value !== null && value !== void 0) {
+					if ((await execAll(ctx.db, `SELECT COUNT(*) as count FROM "${fk.table}" WHERE "${fk.to}" = '${String(value).replace(/'/g, "''")}'`))[0]?.count === 0) errors.push(`Foreign key violation: ${fk.from} references non-existent ${fk.table}.${fk.to}`);
+				}
+			}
+			return {
+				success: errors.length === 0,
+				data: {
+					errors,
+					valid: errors.length === 0
+				},
+				message: errors.length > 0 ? `Validation failed: ${errors.join("; ")}` : "Row is valid"
+			};
+		}
+	});
+	registry.register({
+		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,
+		rowLevel: false,
+		inputSchema: {
+			type: "object",
+			description: "Create a new SQLite table with specified columns",
+			properties: {
+				name: {
+					type: "string",
+					description: "Table name (alphanumeric and underscores, must start with letter)",
+					pattern: "^[a-zA-Z][a-zA-Z0-9_]*$",
+					minLength: 1,
+					maxLength: 128
+				},
+				columns: {
+					type: "array",
+					description: "Column definitions (at least one required)",
+					minItems: 1,
+					items: {
+						type: "object",
+						description: "Column definition",
+						properties: {
+							name: {
+								type: "string",
+								description: "Column name (alphanumeric and underscores)",
+								pattern: "^[a-zA-Z_][a-zA-Z0-9_]*$",
+								minLength: 1,
+								maxLength: 128
+							},
+							type: {
+								type: "string",
+								description: "SQLite column type",
+								enum: [
+									"INTEGER",
+									"TEXT",
+									"REAL",
+									"BLOB",
+									"NUMERIC",
+									"INT",
+									"TINYINT",
+									"SMALLINT",
+									"MEDIUMINT",
+									"BIGINT",
+									"UNSIGNED BIG INT",
+									"INT2",
+									"INT8",
+									"CHARACTER",
+									"VARCHAR",
+									"VARYING CHARACTER",
+									"NCHAR",
+									"NATIVE CHARACTER",
+									"NVARCHAR",
+									"CLOB",
+									"DOUBLE",
+									"DOUBLE PRECISION",
+									"FLOAT",
+									"DECIMAL",
+									"BOOLEAN",
+									"DATE",
+									"DATETIME",
+									"TIMESTAMP"
+								],
+								"x-affinity-mapping": {
+									INTEGER: [
+										"INTEGER",
+										"INT",
+										"TINYINT",
+										"SMALLINT",
+										"MEDIUMINT",
+										"BIGINT",
+										"UNSIGNED BIG INT",
+										"INT2",
+										"INT8"
+									],
+									TEXT: [
+										"TEXT",
+										"CHARACTER",
+										"VARCHAR",
+										"VARYING CHARACTER",
+										"NCHAR",
+										"NATIVE CHARACTER",
+										"NVARCHAR",
+										"CLOB"
+									],
+									REAL: [
+										"REAL",
+										"DOUBLE",
+										"DOUBLE PRECISION",
+										"FLOAT"
+									],
+									NUMERIC: [
+										"NUMERIC",
+										"DECIMAL",
+										"BOOLEAN",
+										"DATE",
+										"DATETIME",
+										"TIMESTAMP"
+									],
+									BLOB: ["BLOB"]
+								}
+							},
+							nullable: {
+								type: "boolean",
+								description: "Whether the column allows NULL values (default: true)",
+								default: true
+							},
+							primaryKey: {
+								type: "boolean",
+								description: "Whether this column is the primary key (default: false). INTEGER PRIMARY KEY will auto-increment.",
+								default: false
+							},
+							unique: {
+								type: "boolean",
+								description: "Whether this column must have unique values (default: false)",
+								default: false
+							},
+							defaultValue: {
+								oneOf: [
+									{ type: "string" },
+									{ type: "number" },
+									{ type: "boolean" },
+									{ type: "null" }
+								],
+								description: "Default value for the column. Use string 'CURRENT_TIMESTAMP' for auto timestamp."
+							},
+							references: {
+								type: "object",
+								description: "Foreign key reference",
+								properties: {
+									table: {
+										type: "string",
+										description: "Referenced table name"
+									},
+									column: {
+										type: "string",
+										description: "Referenced column name"
+									},
+									onDelete: {
+										type: "string",
+										enum: [
+											"CASCADE",
+											"SET NULL",
+											"SET DEFAULT",
+											"RESTRICT",
+											"NO ACTION"
+										],
+										description: "Action on delete (default: NO ACTION)"
+									},
+									onUpdate: {
+										type: "string",
+										enum: [
+											"CASCADE",
+											"SET NULL",
+											"SET DEFAULT",
+											"RESTRICT",
+											"NO ACTION"
+										],
+										description: "Action on update (default: NO ACTION)"
+									}
+								},
+								required: ["table", "column"]
+							}
+						},
+						required: ["name", "type"],
+						additionalProperties: false
+					}
+				},
+				ifNotExists: {
+					type: "boolean",
+					description: "If true, do not throw error if table already exists (default: false)",
+					default: false
+				}
+			},
+			required: ["name", "columns"],
+			additionalProperties: false
+		},
+		handler: async (ctx, params) => {
+			const tableName = params.name;
+			const columns = params.columns;
+			const ifNotExists = params.ifNotExists;
+			if (!tableName) throw new Error("Table name is required");
+			if (!/^[a-zA-Z][a-zA-Z0-9_]*$/.test(tableName)) throw new Error("Table name must start with a letter and contain only alphanumeric characters and underscores");
+			if (!columns || columns.length === 0) throw new Error("At least one column is required");
+			for (const col of columns) if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(col.name)) throw new Error(`Invalid column name: ${col.name}. Must start with a letter or underscore and contain only alphanumeric characters and underscores`);
+			const validTypes = [
+				"INTEGER",
+				"TEXT",
+				"REAL",
+				"BLOB",
+				"NUMERIC",
+				"INT",
+				"TINYINT",
+				"SMALLINT",
+				"MEDIUMINT",
+				"BIGINT",
+				"UNSIGNED BIG INT",
+				"INT2",
+				"INT8",
+				"CHARACTER",
+				"VARCHAR",
+				"VARYING CHARACTER",
+				"NCHAR",
+				"NATIVE CHARACTER",
+				"NVARCHAR",
+				"CLOB",
+				"DOUBLE",
+				"DOUBLE PRECISION",
+				"FLOAT",
+				"DECIMAL",
+				"BOOLEAN",
+				"DATE",
+				"DATETIME",
+				"TIMESTAMP"
+			];
+			for (const col of columns) {
+				const upperType = col.type.toUpperCase();
+				if (!validTypes.includes(upperType)) throw new Error(`Invalid column type: ${col.type}. Valid types are: ${validTypes.join(", ")}`);
+			}
+			if (!ifNotExists) {
+				if (await ctx.schemaService.hasTable(tableName)) throw new Error(`Table '${tableName}' already exists`);
+			}
+			const columnDefs = [];
+			const foreignKeys = [];
+			for (const col of columns) {
+				const parts = [`"${col.name}"`, col.type.toUpperCase()];
+				if (col.primaryKey) {
+					parts.push("PRIMARY KEY");
+					if (col.type.toUpperCase() === "INTEGER" || col.type.toUpperCase() === "INT") parts.push("AUTOINCREMENT");
+				}
+				if (col.nullable === false && !col.primaryKey) parts.push("NOT NULL");
+				if (col.unique && !col.primaryKey) parts.push("UNIQUE");
+				if (col.defaultValue !== void 0) if (col.defaultValue === "CURRENT_TIMESTAMP" || col.defaultValue === "CURRENT_DATE" || col.defaultValue === "CURRENT_TIME") parts.push(`DEFAULT ${col.defaultValue}`);
+				else parts.push(`DEFAULT ${formatValueForSQL(col.defaultValue)}`);
+				columnDefs.push(parts.join(" "));
+				if (col.references) {
+					let fkDef = `FOREIGN KEY ("${col.name}") REFERENCES "${col.references.table}"("${col.references.column}")`;
+					if (col.references.onDelete) fkDef += ` ON DELETE ${col.references.onDelete}`;
+					if (col.references.onUpdate) fkDef += ` ON UPDATE ${col.references.onUpdate}`;
+					foreignKeys.push(fkDef);
+				}
+			}
+			const allDefs = [...columnDefs, ...foreignKeys];
+			const createSQL = `CREATE TABLE ${ifNotExists ? "IF NOT EXISTS " : ""}"${tableName}" (${allDefs.join(", ")})`;
+			await execRun(ctx.db, createSQL);
+			return {
+				success: true,
+				data: {
+					tableName,
+					columnCount: columns.length,
+					sql: createSQL
+				},
+				message: `Table '${tableName}' created successfully`
+			};
+		}
+	});
+	registry.register({
+		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: "Fields to update",
+					additionalProperties: true
+				} },
+				required: ["data"]
+			};
+			return generateUpdateSchema(schemaCtx.tableSchema);
+		},
+		handler: async (ctx, params) => {
+			const data = params.data;
+			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, updateSQL);
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				if (message.includes("UNIQUE constraint failed")) return require_types.errorResult(require_types.SQLiteActionErrorCode.CONSTRAINT_VIOLATION, `Unique constraint violation: ${message}`);
+				throw error;
+			}
+			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: {
+					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)"
+				},
+				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
+				}
+			};
+		}
+	});
+}
+/**
+* Formats a value for SQL insertion
+*/
+function formatValueForSQL(value) {
+	if (value === null || value === void 0) return "NULL";
+	if (typeof value === "number") return String(value);
+	if (typeof value === "boolean") return value ? "1" : "0";
+	if (value instanceof Date) return `'${value.toISOString()}'`;
+	if (typeof value === "object") return `'${JSON.stringify(value).replace(/'/g, "''")}'`;
+	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) {
+	const upperType = sqliteType.toUpperCase();
+	if (upperType.includes("INT")) return { type: "integer" };
+	if (upperType.includes("REAL") || upperType.includes("FLOAT") || upperType.includes("DOUBLE")) return { type: "number" };
+	if (upperType.includes("BOOL")) return {
+		type: "boolean",
+		description: "Stored as INTEGER (0/1)"
+	};
+	if (upperType.includes("DATE") || upperType.includes("TIME")) return {
+		type: "string",
+		format: "date-time"
+	};
+	if (upperType.includes("BLOB")) return {
+		type: "string",
+		format: "binary",
+		description: "Base64 encoded binary data"
+	};
+	return { type: "string" };
+}
+/**
+* Generates JSON Schema for insert action based on table schema
+*/
+function generateInsertSchema(tableSchema) {
+	const properties = {};
+	const required = [];
+	for (const col of tableSchema.columns) {
+		if (col.pk > 0 && col.type.toUpperCase().includes("INTEGER")) continue;
+		const propSchema = { ...sqliteTypeToJsonSchema(col.type) };
+		if (col.dfltValue !== null) {
+			propSchema.default = col.dfltValue;
+			propSchema.description = `${propSchema.description ?? ""}${propSchema.description ? ". " : ""}Default: ${col.dfltValue}`.trim();
+		}
+		if (col.notnull && col.dfltValue === null && col.pk === 0) required.push(col.name);
+		properties[col.name] = propSchema;
+	}
+	return {
+		type: "object",
+		description: `Insert a new row into "${tableSchema.name}" table`,
+		properties: { data: {
+			type: "object",
+			description: "Row data to insert",
+			properties,
+			required: required.length > 0 ? required : void 0,
+			additionalProperties: false
+		} },
+		required: ["data"]
+	};
+}
+/**
+* Generates JSON Schema for validate action based on table schema
+*/
+function generateValidateSchema(tableSchema) {
+	const columnInfo = tableSchema.columns.map((col) => ({
+		name: col.name,
+		type: col.type,
+		nullable: !col.notnull,
+		primaryKey: col.pk > 0
+	}));
+	const foreignKeyInfo = tableSchema.foreignKeys.map((fk) => ({
+		column: fk.from,
+		references: `${fk.table}.${fk.to}`
+	}));
+	return {
+		type: "object",
+		description: `Validate row data against "${tableSchema.name}" table constraints`,
+		properties: {},
+		additionalProperties: false,
+		"x-table-schema": {
+			columns: columnInfo,
+			foreignKeys: foreignKeyInfo
+		}
+	};
+}
+/**
+* Generates JSON Schema for duplicate action based on table schema
+*/
+function generateDuplicateSchema(tableSchema) {
+	const pkColumn = tableSchema.primaryKey[0] ?? "rowid";
+	const copiedColumns = tableSchema.columns.filter((col) => col.name !== pkColumn).map((col) => col.name);
+	return {
+		type: "object",
+		description: `Create a copy of the row (excluding primary key "${pkColumn}")`,
+		properties: {},
+		additionalProperties: false,
+		"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;