@sqg/sqg 0.11.0 → 0.13.0

package/dist/sqg.mjs

@@ -2,27 +2,32 @@
 import { exit } from "node:process";
 import { Command } from "commander";
 import consola, { LogLevels } from "consola";
+import updateNotifier from "update-notifier";
+import pc from "picocolors";
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import * as clack from "@clack/prompts";
 import { randomUUID } from "node:crypto";
 import { homedir, tmpdir } from "node:os";
-import { basename, dirname, extname, join, resolve } from "node:path";
+import { basename, dirname, extname, join, relative, resolve } from "node:path";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import YAML from "yaml";
+import { camelCase, pascalCase } from "es-toolkit/string";
 import Handlebars from "handlebars";
 import { z } from "zod";
 import { DuckDBEnumType, DuckDBInstance, DuckDBListType, DuckDBMapType, DuckDBStructType } from "@duckdb/node-api";
 import { LRParser } from "@lezer/lr";
-import { camelCase, isNotNil, pascalCase, sortBy } from "es-toolkit";
+import { isNotNil, sortBy } from "es-toolkit";
+import { PostgreSqlContainer } from "@testcontainers/postgresql";
 import { Client } from "pg";
 import types from "pg-types";
 import BetterSqlite3 from "better-sqlite3";
-import { camelCase as camelCase$1, pascalCase as pascalCase$1 } from "es-toolkit/string";
 import prettier from "prettier/standalone";
 import prettierPluginJava from "prettier-plugin-java";
 import typescriptPlugin from "prettier/parser-typescript";
 import estree from "prettier/plugins/estree";
+import yoctoSpinner from "yocto-spinner";
 
 //#region src/constants.ts
 /**
@@ -360,12 +365,6 @@ function formatErrorForOutput(err) {
 * SQG Project Initialization - Creates new SQG projects with example files
 */
 /**
-* Get the default generator for a language preference
-*/
-function getDefaultGenerator() {
-	return "typescript/sqlite";
-}
-/**
 * Generate example SQL content based on engine
 */
 function getExampleSql(engine) {
@@ -561,14 +560,14 @@ DELETE FROM posts WHERE id = \${id};
 /**
 * Generate sqg.yaml configuration
 */
-function getConfigYaml(generator, output) {
+function getConfigYaml(generator, output, projectName) {
 	const isJava = parseGenerator(generator).language === "java";
 	return `# SQG Configuration
 # Generated by: sqg init
 # Documentation: https://sqg.dev
 
 version: 1
-name: my-project
+name: ${projectName}
 
 sql:
   - files:
@@ -581,11 +580,70 @@ sql:
 `;
 }
 /**
-* Initialize a new SQG project
+* Run interactive wizard when no --generator flag is provided
 */
-async function initProject(options) {
-	const generator = options.generator || getDefaultGenerator();
-	const output = options.output || "./generated";
+async function runInteractiveInit(options) {
+	clack.intro(pc.bold("Create a new SQG project"));
+	const projectName = await clack.text({
+		message: "Project name",
+		placeholder: "my-project",
+		defaultValue: "my-project",
+		validate: (value) => {
+			if (!value?.trim()) return "Project name is required";
+		}
+	});
+	if (clack.isCancel(projectName)) {
+		clack.cancel("Operation cancelled");
+		process.exit(0);
+	}
+	const generatorOptions = [];
+	for (const shortName of SHORT_GENERATOR_NAMES) {
+		const info = GENERATORS[`${shortName}/${Object.entries(GENERATORS).find(([k]) => k.startsWith(`${shortName}/`))?.[1]?.driver}`];
+		if (info) generatorOptions.push({
+			value: shortName,
+			label: shortName,
+			hint: info.description
+		});
+	}
+	const generator = await clack.select({
+		message: "Generator",
+		options: generatorOptions
+	});
+	if (clack.isCancel(generator)) {
+		clack.cancel("Operation cancelled");
+		process.exit(0);
+	}
+	const output = await clack.text({
+		message: "Output directory",
+		placeholder: "./generated",
+		defaultValue: options.output || "./generated"
+	});
+	if (clack.isCancel(output)) {
+		clack.cancel("Operation cancelled");
+		process.exit(0);
+	}
+	clack.log.step("Files to create:");
+	clack.log.message(`  ${pc.dim("sqg.yaml")}      Project configuration`);
+	clack.log.message(`  ${pc.dim("queries.sql")}    Example SQL queries`);
+	clack.log.message(`  ${pc.dim(`${output}/`)}      Output directory`);
+	const confirm = await clack.confirm({ message: "Create files?" });
+	if (clack.isCancel(confirm) || !confirm) {
+		clack.cancel("Operation cancelled");
+		process.exit(0);
+	}
+	await createProjectFiles({
+		generator,
+		output,
+		force: options.force,
+		projectName
+	});
+	clack.outro(`Done! Run: ${pc.bold("sqg sqg.yaml")}`);
+}
+/**
+* Create project files (shared between interactive and non-interactive modes)
+*/
+async function createProjectFiles(options) {
+	const { generator, output, force, projectName } = options;
 	if (!isValidGenerator(generator)) {
 		const similar = findSimilarGenerators(generator);
 		throw new InvalidGeneratorError(generator, [...SHORT_GENERATOR_NAMES, ...GENERATOR_NAMES], similar.length > 0 ? similar[0] : void 0);
@@ -593,32 +651,40 @@ async function initProject(options) {
 	const engine = parseGenerator(generator).engine;
 	const configPath = "sqg.yaml";
 	const sqlPath = "queries.sql";
-	if (!options.force) {
+	if (!force) {
 		if (existsSync(configPath)) throw new SqgError(`File already exists: ${configPath}`, "VALIDATION_ERROR", "Use --force to overwrite existing files");
 		if (existsSync(sqlPath)) throw new SqgError(`File already exists: ${sqlPath}`, "VALIDATION_ERROR", "Use --force to overwrite existing files");
 	}
-	if (!existsSync(output)) {
-		mkdirSync(output, { recursive: true });
-		consola.success(`Created output directory: ${output}`);
-	}
-	writeFileSync(configPath, getConfigYaml(generator, output));
-	consola.success(`Created ${configPath}`);
+	if (!existsSync(output)) mkdirSync(output, { recursive: true });
+	writeFileSync(configPath, getConfigYaml(generator, output, projectName));
 	writeFileSync(sqlPath, getExampleSql(engine));
-	consola.success(`Created ${sqlPath}`);
-	consola.box(`
-SQG project initialized!
-
-Generator: ${generator}
-Engine: ${engine}
-Output: ${output}
-
-Next steps:
-  1. Edit queries.sql to add your SQL queries
-  2. Run: sqg sqg.yaml
-  3. Import the generated code from ${output}
-
-Documentation: https://sqg.dev
-  `);
+}
+/**
+* Initialize a new SQG project
+*/
+async function initProject(options) {
+	if (!options.generator && process.stdin.isTTY) {
+		await runInteractiveInit(options);
+		return;
+	}
+	const generator = options.generator || "typescript/sqlite";
+	const output = options.output || "./generated";
+	await createProjectFiles({
+		generator,
+		output,
+		force: options.force,
+		projectName: "my-project"
+	});
+	const generatorInfo = parseGenerator(generator);
+	clack.intro(pc.bold("SQG project initialized!"));
+	clack.log.info(`Generator: ${generator}`);
+	clack.log.info(`Engine: ${generatorInfo.engine}`);
+	clack.log.info(`Output: ${output}`);
+	clack.log.step("Next steps:");
+	clack.log.message("  1. Edit queries.sql to add your SQL queries");
+	clack.log.message("  2. Run: sqg sqg.yaml");
+	clack.log.message(`  3. Import the generated code from ${output}`);
+	clack.outro("Documentation: https://sqg.dev");
 }
 
 //#endregion
@@ -670,8 +736,9 @@ var MapType = class {
 	}
 };
 var EnumType = class {
-	constructor(values) {
+	constructor(values, name) {
 		this.values = values;
+		this.name = name;
 	}
 	toString() {
 		return `ENUM(${this.values.map((v) => `'${v}'`).join(", ")})`;
@@ -744,7 +811,7 @@ var TableInfo = class {
 };
 function parseSQLQueries(filePath, extraVariables) {
 	const content = readFileSync(filePath, "utf-8");
-	consola.info(`Parsing SQL file: ${filePath}`);
+	consola.debug(`Parsing SQL file: ${filePath}`);
 	consola.debug(`File start: ${content.slice(0, 200)}`);
 	const queries = [];
 	const tables = [];
@@ -933,9 +1000,9 @@ function parseSQLQueries(filePath, extraVariables) {
 			consola.debug(`Added query: ${name} (${queryType})`);
 		}
 	while (cursor.next());
-	consola.info(`Total queries parsed: ${queries.length}, tables: ${tables.length}`);
-	consola.info(`Query names: ${queries.map((q) => q.id).join(", ")}`);
-	if (tables.length > 0) consola.info(`Table names: ${tables.map((t) => t.id).join(", ")}`);
+	consola.debug(`Total queries parsed: ${queries.length}, tables: ${tables.length}`);
+	consola.debug(`Query names: ${queries.map((q) => q.id).join(", ")}`);
+	if (tables.length > 0) consola.debug(`Table names: ${tables.map((t) => t.id).join(", ")}`);
 	return {
 		queries,
 		tables
@@ -944,7 +1011,7 @@ function parseSQLQueries(filePath, extraVariables) {
 
 //#endregion
 //#region src/db/types.ts
-async function initializeDatabase(queries, execQueries) {
+async function initializeDatabase(queries, execQueries, reporter) {
 	const migrationQueries = queries.filter((q) => q.isMigrate);
 	sortBy(migrationQueries, [(q) => Number(q.id.split("_")[1])]);
 	for (const query of migrationQueries) try {
@@ -961,7 +1028,7 @@ async function initializeDatabase(queries, execQueries) {
 		throw error;
 	}
 	if (migrationQueries.length + testdataQueries.length === 0) consola.warn("No migration or testdata queries found");
-	consola.success("Database initialized successfully");
+	reporter?.onDatabaseInitialized?.();
 }
 
 //#endregion
@@ -988,7 +1055,7 @@ function convertType(type) {
 const duckdb = new class {
 	db;
 	connection;
-	async initializeDatabase(queries) {
+	async initializeDatabase(queries, reporter) {
 		this.db = await DuckDBInstance.create(":memory:");
 		this.connection = await this.db.connect();
 		await initializeDatabase(queries, async (query) => {
@@ -997,18 +1064,17 @@ const duckdb = new class {
 			} catch (e) {
 				throw new SqlExecutionError(e.message, query.id, query.filename, query.rawQuery, e);
 			}
-		});
+		}, reporter);
 	}
-	async executeQueries(queries) {
+	async executeQueries(queries, reporter) {
 		const connection = this.connection;
 		if (!connection) throw new DatabaseError("DuckDB connection not initialized", "duckdb", "This is an internal error. Check that migrations completed successfully.");
 		try {
 			const executableQueries = queries.filter((q) => !q.skipGenerateFunction);
 			for (const query of executableQueries) {
-				consola.info(`Executing query: ${query.id}`);
+				reporter?.onQueryStart?.(query.id);
 				await this.executeQuery(connection, query);
-				if (query.isQuery) {}
-				consola.success(`Query ${query.id} executed successfully`);
+				reporter?.onQueryComplete?.(query.id);
 			}
 		} catch (error) {
 			consola.error("Error executing queries:", error.message);
@@ -1056,11 +1122,11 @@ const duckdb = new class {
 			throw error;
 		}
 	}
-	async introspectTables(tables) {
+	async introspectTables(tables, reporter) {
 		const connection = this.connection;
 		if (!connection) throw new DatabaseError("DuckDB connection not initialized", "duckdb", "This is an internal error. Check that migrations completed successfully.");
 		for (const table of tables) {
-			consola.info(`Introspecting table schema: ${table.tableName}`);
+			reporter?.onTableStart?.(table.tableName);
 			try {
 				const descRows = (await connection.runAndReadAll(`DESCRIBE ${table.tableName}`)).getRows();
 				const nullabilityMap = /* @__PURE__ */ new Map();
@@ -1074,7 +1140,7 @@ const duckdb = new class {
 					nullable: nullabilityMap.get(name) ?? true
 				}));
 				consola.debug(`Table ${table.tableName} columns:`, table.columns);
-				consola.success(`Introspected table: ${table.tableName} (${table.columns.length} columns)`);
+				reporter?.onTableComplete?.(table.tableName, table.columns.length);
 			} catch (error) {
 				consola.error(`Failed to introspect table '${table.tableName}':`, error);
 				throw error;
@@ -1088,103 +1154,178 @@ const duckdb = new class {
 
 //#endregion
 //#region src/db/postgres.ts
-const databaseName = "sqg-db-temp";
-let containerInstance = null;
-async function startTestContainer() {
-	if (containerInstance) return containerInstance.getConnectionUri();
-	consola.info("Starting PostgreSQL container via testcontainers...");
-	const { PostgreSqlContainer } = await import("@testcontainers/postgresql");
-	containerInstance = await new PostgreSqlContainer("postgres:16-alpine").withDatabase("sqg-db").withUsername("sqg").withPassword("secret").start();
-	const connectionUri = containerInstance.getConnectionUri();
-	consola.success(`PostgreSQL container started at: ${connectionUri}`);
-	return connectionUri;
-}
-async function stopTestContainer() {
-	if (containerInstance) {
-		consola.info("Stopping PostgreSQL container...");
-		await containerInstance.stop();
-		containerInstance = null;
-	}
-}
-async function getConnectionString() {
-	if (process.env.SQG_POSTGRES_URL) return process.env.SQG_POSTGRES_URL;
-	return await startTestContainer();
-}
-function getTempConnectionString(baseUrl) {
-	return baseUrl.replace(/\/[^/]+$/, `/${databaseName}`);
-}
+const tempDatabaseName = "sqg-db-temp";
 const typeIdToName = /* @__PURE__ */ new Map();
 for (const [name, id] of Object.entries(types.builtins)) typeIdToName.set(Number(id), name);
-let dynamicTypeCache = /* @__PURE__ */ new Map();
-async function loadTypeCache(db) {
-	const result = await db.query(`
-    SELECT t.oid, t.typname, t.typtype, t.typelem, et.typname AS elemtype
-    FROM pg_type t
-    LEFT JOIN pg_type et ON t.typelem = et.oid
-    WHERE t.typtype IN ('b', 'e', 'r', 'c') -- base, enum, range, composite
-       OR t.typelem != 0 -- array types
-  `);
-	dynamicTypeCache = /* @__PURE__ */ new Map();
-	for (const row of result.rows) {
-		const oid = row.oid;
-		let typeName = row.typname;
-		if (typeName.startsWith("_") && row.elemtype) typeName = `_${row.elemtype.toUpperCase()}`;
-		else typeName = typeName.toUpperCase();
-		dynamicTypeCache.set(oid, typeName);
+/**
+* External database mode: connects directly to the user's database.
+* Uses a single transaction for the entire session and rolls back on close,
+* so the database is never modified. Individual queries use savepoints.
+*/
+var ExternalDbMode = class {
+	constructor(connectionString) {
+		this.connectionString = connectionString;
 	}
-}
-function getTypeName(dataTypeID) {
-	const cached = dynamicTypeCache.get(dataTypeID);
-	if (cached) return cached;
-	return typeIdToName.get(dataTypeID) || `type_${dataTypeID}`;
-}
-const postgres = new class {
+	async connect() {
+		const db = new Client({ connectionString: this.connectionString });
+		try {
+			await db.connect();
+		} catch (e) {
+			throw new DatabaseError(`Failed to connect to PostgreSQL: ${e.message}`, "postgres", `Check that PostgreSQL is running and accessible at ${this.connectionString}.`);
+		}
+		await db.query("BEGIN");
+		return db;
+	}
+	async wrapQuery(db, fn) {
+		try {
+			await db.query("SAVEPOINT sqg_query");
+			return await fn();
+		} finally {
+			await db.query("ROLLBACK TO SAVEPOINT sqg_query");
+		}
+	}
+	async close(db) {
+		await db.query("ROLLBACK");
+		await db.end();
+	}
+};
+/**
+* Temp database mode: creates a temporary database for SQG to work in.
+* Connects to the provided server first (dbInitial) to CREATE the temp DB,
+* then connects to the temp DB for all operations.
+* On close, drops the temp DB and optionally stops the testcontainer.
+*/
+var TempDbMode = class {
 	dbInitial;
-	db;
-	usingTestContainer = false;
-	async initializeDatabase(queries) {
-		const connectionString = await getConnectionString();
-		const connectionStringTemp = getTempConnectionString(connectionString);
-		this.usingTestContainer = containerInstance !== null;
-		this.dbInitial = new Client({ connectionString });
-		this.db = new Client({ connectionString: connectionStringTemp });
+	container = null;
+	constructor(connectionString, container) {
+		this.connectionString = connectionString;
+		this.container = container;
+	}
+	async connect() {
+		this.dbInitial = new Client({ connectionString: this.connectionString });
 		try {
 			await this.dbInitial.connect();
 		} catch (e) {
-			throw new DatabaseError(`Failed to connect to PostgreSQL: ${e.message}`, "postgres", `Check that PostgreSQL is running and accessible at ${connectionString}. Set SQG_POSTGRES_URL environment variable to use a different connection string.`);
+			throw new DatabaseError(`Failed to connect to PostgreSQL: ${e.message}`, "postgres", `Check that PostgreSQL is running and accessible at ${this.connectionString}. Set SQG_POSTGRES_URL environment variable to use a different connection string.`);
 		}
 		try {
-			await this.dbInitial.query(`DROP DATABASE IF EXISTS "${databaseName}";`);
+			await this.dbInitial.query(`DROP DATABASE IF EXISTS "${tempDatabaseName}";`);
 		} catch (error) {}
 		try {
-			await this.dbInitial.query(`CREATE DATABASE "${databaseName}";`);
+			await this.dbInitial.query(`CREATE DATABASE "${tempDatabaseName}";`);
 		} catch (error) {
 			throw new DatabaseError(`Failed to create temporary database: ${error.message}`, "postgres", "Check PostgreSQL user permissions to create databases");
 		}
+		const db = new Client({ connectionString: this.connectionString.replace(/\/[^/]+$/, `/${tempDatabaseName}`) });
 		try {
-			await this.db.connect();
+			await db.connect();
 		} catch (e) {
 			throw new DatabaseError(`Failed to connect to temporary database: ${e.message}`, "postgres");
 		}
+		return db;
+	}
+	async wrapQuery(db, fn) {
+		try {
+			await db.query("BEGIN");
+			return await fn();
+		} finally {
+			await db.query("ROLLBACK");
+		}
+	}
+	async close(db) {
+		await db.end();
+		await this.dbInitial.query(`DROP DATABASE IF EXISTS "${tempDatabaseName}"`);
+		await this.dbInitial.end();
+		if (this.container) {
+			await this.container.stop();
+			this.container = null;
+		}
+	}
+};
+const postgres = new class {
+	db;
+	mode;
+	dynamicTypeCache = /* @__PURE__ */ new Map();
+	enumTypeCache = /* @__PURE__ */ new Map();
+	async startContainer(reporter) {
+		reporter?.onContainerStarting?.();
+		const container = await new PostgreSqlContainer("postgres:16-alpine").withDatabase("sqg-db").withUsername("sqg").withPassword("secret").start();
+		const connectionUri = container.getConnectionUri();
+		reporter?.onContainerStarted?.(connectionUri);
+		return {
+			connectionUri,
+			container
+		};
+	}
+	async loadTypeCache(db) {
+		const result = await db.query(`
+      SELECT t.oid, t.typname, t.typtype, t.typelem, et.typname AS elemtype,
+             e.enumlabel
+      FROM pg_type t
+      LEFT JOIN pg_type et ON t.typelem = et.oid
+      LEFT JOIN pg_enum e ON t.oid = e.enumtypid AND t.typtype = 'e'
+      WHERE t.typtype IN ('b', 'e', 'r', 'c') -- base, enum, range, composite
+         OR t.typelem != 0 -- array types
+      ORDER BY t.oid, e.enumsortorder
+    `);
+		this.dynamicTypeCache = /* @__PURE__ */ new Map();
+		this.enumTypeCache = /* @__PURE__ */ new Map();
+		const enumsByOid = /* @__PURE__ */ new Map();
+		for (const row of result.rows) {
+			const oid = row.oid;
+			let typeName = row.typname;
+			if (typeName.startsWith("_") && row.elemtype) typeName = `_${row.elemtype.toUpperCase()}`;
+			else typeName = typeName.toUpperCase();
+			this.dynamicTypeCache.set(oid, typeName);
+			if (row.enumlabel) {
+				if (!enumsByOid.has(oid)) enumsByOid.set(oid, {
+					name: row.typname,
+					values: []
+				});
+				enumsByOid.get(oid).values.push(row.enumlabel);
+			}
+		}
+		for (const [oid, { name, values }] of enumsByOid) this.enumTypeCache.set(oid, new EnumType(values, name));
+	}
+	getTypeName(dataTypeID) {
+		const cached = this.dynamicTypeCache.get(dataTypeID);
+		if (cached) return cached;
+		return typeIdToName.get(dataTypeID) || `type_${dataTypeID}`;
+	}
+	getColumnType(dataTypeID) {
+		const enumType = this.enumTypeCache.get(dataTypeID);
+		if (enumType) return enumType;
+		return this.getTypeName(dataTypeID);
+	}
+	async initializeDatabase(queries, reporter) {
+		const externalUrl = process.env.SQG_POSTGRES_URL;
+		this.dynamicTypeCache = /* @__PURE__ */ new Map();
+		this.enumTypeCache = /* @__PURE__ */ new Map();
+		if (externalUrl) this.mode = new ExternalDbMode(externalUrl);
+		else {
+			const { connectionUri, container } = await this.startContainer(reporter);
+			this.mode = new TempDbMode(connectionUri, container);
+		}
+		this.db = await this.mode.connect();
 		await initializeDatabase(queries, async (query) => {
 			try {
 				await this.db.query(query.rawQuery);
 			} catch (e) {
 				throw new SqlExecutionError(e.message, query.id, query.filename, query.rawQuery, e);
 			}
-		});
-		await loadTypeCache(this.db);
+		}, reporter);
+		await this.loadTypeCache(this.db);
 	}
-	async executeQueries(queries) {
+	async executeQueries(queries, reporter) {
 		const db = this.db;
 		if (!db) throw new DatabaseError("PostgreSQL database not initialized", "postgres", "This is an internal error. Check that migrations completed successfully.");
 		try {
 			const executableQueries = queries.filter((q) => !q.skipGenerateFunction);
 			for (const query of executableQueries) {
-				consola.debug(`Executing query: ${query.id}`);
+				reporter?.onQueryStart?.(query.id);
 				await this.executeQuery(db, query);
-				if (query.isQuery) {}
-				consola.success(`Query ${query.id} executed successfully`);
+				reporter?.onQueryComplete?.(query.id);
 			}
 		} catch (error) {
 			consola.error("Error executing queries:", error.message);
@@ -1194,7 +1335,7 @@ const postgres = new class {
 	async executeQuery(db, query) {
 		const statement = query.queryPositional;
 		try {
-			consola.info("Query:", statement.sql);
+			consola.debug("Query:", statement.sql);
 			const parameterValues = statement.parameters.map((p) => {
 				const value = p.value;
 				if (value.startsWith("'") && value.endsWith("'") || value.startsWith("\"") && value.endsWith("\"")) return value.slice(1, -1);
@@ -1208,8 +1349,9 @@ const postgres = new class {
 				if (paramTypeResult.rows.length === statement.parameters.length) {
 					const paramTypes = /* @__PURE__ */ new Map();
 					for (let i = 0; i < statement.parameters.length; i++) {
-						const typeName = getTypeName(Number(paramTypeResult.rows[i].oid));
-						paramTypes.set(statement.parameters[i].name, typeName);
+						const oid = Number(paramTypeResult.rows[i].oid);
+						const colType = this.getColumnType(oid);
+						paramTypes.set(statement.parameters[i].name, colType);
 					}
 					query.parameterTypes = paramTypes;
 					consola.debug("Parameter types:", Object.fromEntries(paramTypes));
@@ -1217,20 +1359,14 @@ const postgres = new class {
 			} catch (e) {
 				consola.debug(`Parameter type introspection failed for ${query.id}, using heuristic:`, e.message);
 			}
-			let result;
-			try {
-				await db.query("BEGIN");
-				result = await db.query(statement.sql, parameterValues);
-			} finally {
-				await db.query("ROLLBACK");
-			}
+			const result = await this.mode.wrapQuery(db, () => db.query(statement.sql, parameterValues));
 			if (query.isQuery) {
 				const columnNames = result.fields.map((field) => field.name);
 				const columnTypes = result.fields.map((field) => {
-					return getTypeName(field.dataTypeID);
+					return this.getColumnType(field.dataTypeID);
 				});
 				consola.debug("Columns:", columnNames);
-				consola.debug("Types:", columnTypes);
+				consola.debug("Types:", columnTypes.map((t) => t.toString()));
 				query.columns = columnNames.map((name, index) => ({
 					name,
 					type: columnTypes[index],
@@ -1247,11 +1383,11 @@ const postgres = new class {
 			throw error;
 		}
 	}
-	async introspectTables(tables) {
+	async introspectTables(tables, reporter) {
 		const db = this.db;
 		if (!db) throw new DatabaseError("PostgreSQL database not initialized", "postgres", "This is an internal error. Check that migrations completed successfully.");
 		for (const table of tables) {
-			consola.info(`Introspecting table schema: ${table.tableName}`);
+			reporter?.onTableStart?.(table.tableName);
 			try {
 				table.columns = (await db.query(`SELECT column_name, data_type, is_nullable
            FROM information_schema.columns
@@ -1261,7 +1397,7 @@ const postgres = new class {
 					type: row.data_type.toUpperCase(),
 					nullable: row.is_nullable === "YES"
 				}));
-				consola.success(`Introspected table: ${table.tableName} (${table.columns.length} columns)`);
+				reporter?.onTableComplete?.(table.tableName, table.columns.length);
 			} catch (error) {
 				consola.error(`Failed to introspect table '${table.tableName}':`, error);
 				throw error;
@@ -1269,10 +1405,9 @@ const postgres = new class {
 		}
 	}
 	async close() {
-		await this.db.end();
-		await this.dbInitial.query(`DROP DATABASE IF EXISTS "${databaseName}"`);
-		await this.dbInitial.end();
-		if (this.usingTestContainer) await stopTestContainer();
+		await this.mode.close(this.db);
+		this.dynamicTypeCache = /* @__PURE__ */ new Map();
+		this.enumTypeCache = /* @__PURE__ */ new Map();
 	}
 }();
 
@@ -1280,7 +1415,7 @@ const postgres = new class {
 //#region src/db/sqlite.ts
 const sqlite = new class {
 	db;
-	async initializeDatabase(queries) {
+	async initializeDatabase(queries, reporter) {
 		const db = new BetterSqlite3(":memory:");
 		await initializeDatabase(queries, (query) => {
 			try {
@@ -1289,37 +1424,36 @@ const sqlite = new class {
 				throw new SqlExecutionError(e.message, query.id, query.filename, query.rawQuery, e);
 			}
 			return Promise.resolve();
-		});
+		}, reporter);
 		this.db = db;
 	}
-	executeQueries(queries) {
+	executeQueries(queries, reporter) {
 		const db = this.db;
 		if (!db) throw new DatabaseError("SQLite database not initialized", "sqlite", "This is an internal error. Migrations may have failed silently.");
 		try {
 			const executableQueries = queries.filter((q) => !q.skipGenerateFunction);
 			for (const query of executableQueries) {
-				consola.info(`Executing query: ${query.id}`);
+				reporter?.onQueryStart?.(query.id);
 				this.executeQuery(db, query);
-				if (query.isQuery) {}
-				consola.success(`Query ${query.id} executed successfully`);
+				reporter?.onQueryComplete?.(query.id);
 			}
 		} catch (error) {
 			consola.error("Error executing queries:", error.message);
 			throw error;
 		}
 	}
-	introspectTables(tables) {
+	introspectTables(tables, reporter) {
 		const db = this.db;
 		if (!db) throw new DatabaseError("SQLite database not initialized", "sqlite", "This is an internal error. Migrations may have failed silently.");
 		for (const table of tables) {
-			consola.info(`Introspecting table schema: ${table.tableName}`);
+			reporter?.onTableStart?.(table.tableName);
 			const info = this.getTableInfo(db, table.tableName);
 			table.columns = Array.from(info.values()).map((col) => ({
 				name: col.name,
 				type: col.type || "TEXT",
 				nullable: col.notnull === 0 && col.pk === 0
 			}));
-			consola.success(`Introspected table: ${table.tableName} (${table.columns.length} columns)`);
+			reporter?.onTableComplete?.(table.tableName, table.columns.length);
 		}
 	}
 	close() {
@@ -1534,6 +1668,10 @@ var JavaTypeMapper = class JavaTypeMapper extends TypeMapper {
 		"false",
 		"null"
 	]);
+	getTypeName(column, path = "") {
+		if (column.type instanceof EnumType && column.type.name) return path + pascalCase(column.type.name);
+		return super.getTypeName(column, path);
+	}
 	mapPrimitiveType(type, _nullable) {
 		const upperType = type.toString().toUpperCase();
 		const mappedType = this.typeMap[upperType];
@@ -1585,6 +1723,7 @@ var JavaTypeMapper = class JavaTypeMapper extends TypeMapper {
 		return name;
 	}
 	parseValue(column, value, path) {
+		if (column.type instanceof EnumType && column.type.name) return `${pascalCase(column.type.name)}.fromValue((String)${value})`;
 		if (column.type instanceof ListType) {
 			const elementType = this.getTypeName({
 				name: column.name,
@@ -1810,13 +1949,13 @@ var JavaGenerator = class extends BaseGenerator {
 		return engine === "duckdb";
 	}
 	getFunctionName(id) {
-		return camelCase$1(id);
+		return camelCase(id);
 	}
 	getFilename(sqlFileName) {
-		return `${pascalCase$1(sqlFileName)}.java`;
+		return `${pascalCase(sqlFileName)}.java`;
 	}
 	getClassName(name) {
-		return pascalCase$1(name);
+		return pascalCase(name);
 	}
 	partsToString(parts) {
 		const stringParts = [];
@@ -1861,6 +2000,56 @@ var JavaGenerator = class extends BaseGenerator {
 		Handlebars.registerHelper("appenderType", (column) => {
 			return this.mapType(column);
 		});
+		Handlebars.registerHelper("declareEnums", (queryHelpers) => {
+			const enumTypes = /* @__PURE__ */ new Map();
+			for (const qh of queryHelpers) {
+				for (const col of qh.query.columns) if (col.type instanceof EnumType && col.type.name) enumTypes.set(col.type.name, col.type);
+				if (qh.query.parameterTypes) {
+					for (const colType of qh.query.parameterTypes.values()) if (colType instanceof EnumType && colType.name) enumTypes.set(colType.name, colType);
+				}
+			}
+			if (enumTypes.size === 0) return "";
+			const parts = [];
+			for (const [, enumType] of enumTypes) {
+				const enumName = pascalCase(enumType.name);
+				const sanitized = enumType.values.map((v) => {
+					let ident = v.toUpperCase().replace(/[^A-Za-z0-9_]/g, "_");
+					if (ident.length > 0 && /^[0-9]/.test(ident)) ident = `_${ident}`;
+					if (ident.length === 0) ident = "_EMPTY";
+					return ident;
+				});
+				const usedIdents = /* @__PURE__ */ new Set();
+				const finalIdents = sanitized.map((base) => {
+					if (!usedIdents.has(base)) {
+						usedIdents.add(base);
+						return base;
+					}
+					let counter = 2;
+					let candidate = `${base}_${counter}`;
+					while (usedIdents.has(candidate)) {
+						counter++;
+						candidate = `${base}_${counter}`;
+					}
+					usedIdents.add(candidate);
+					return candidate;
+				});
+				const entries = enumType.values.map((v, i) => `${finalIdents[i]}("${v}")`);
+				parts.push(`public enum ${enumName} {
+    ${entries.join(", ")};
+    private final String value;
+    private static final java.util.Map<String, ${enumName}> BY_VALUE =
+        java.util.Map.ofEntries(java.util.Arrays.stream(values()).map(v -> java.util.Map.entry(v.value, v)).toArray(java.util.Map.Entry[]::new));
+    ${enumName}(String value) { this.value = value; }
+    public String getValue() { return value; }
+    public static ${enumName} fromValue(String value) {
+        ${enumName} result = BY_VALUE.get(value);
+        if (result == null) throw new IllegalArgumentException("Unknown value: " + value);
+        return result;
+    }
+}`);
+			}
+			return new Handlebars.SafeString(parts.join("\n\n    "));
+		});
 		Handlebars.registerHelper("readColumns", (queryHelper) => {
 			const query = queryHelper.query;
 			if (queryHelper.isPluck) return this.readColumn({
@@ -2003,7 +2192,7 @@ var TsGenerator = class extends BaseGenerator {
 		super(template, new TypeScriptTypeMapper());
 	}
 	getFunctionName(id) {
-		return camelCase$1(id);
+		return camelCase(id);
 	}
 	isCompatibleWith(_engine) {
 		return true;
@@ -2012,7 +2201,7 @@ var TsGenerator = class extends BaseGenerator {
 		return `${sqlFileName}.ts`;
 	}
 	getClassName(name) {
-		return pascalCase$1(name);
+		return pascalCase(name);
 	}
 	async beforeGenerate(_projectDir, _gen, _queries, _tables) {
 		Handlebars.registerHelper("quote", (value) => this.quote(value));
@@ -2354,7 +2543,12 @@ var SqlQueryHelper = class {
 			const rawType = this.query.parameterTypes?.get(param.name);
 			let isArray = false;
 			let arrayBaseType = null;
-			if (rawType instanceof ListType) {
+			let isEnum = false;
+			let enumClassName = null;
+			if (rawType instanceof EnumType && rawType.name) {
+				isEnum = true;
+				enumClassName = pascalCase(rawType.name);
+			} else if (rawType instanceof ListType) {
 				isArray = true;
 				arrayBaseType = rawType.baseType.toString();
 			} else if (typeof rawType === "string" && rawType.startsWith("_")) {
@@ -2365,7 +2559,9 @@ var SqlQueryHelper = class {
 				name: param.name,
 				type: vars.get(param.name),
 				isArray,
-				arrayBaseType
+				arrayBaseType,
+				isEnum,
+				enumClassName
 			};
 		});
 	}
@@ -2487,7 +2683,7 @@ function createExtraVariables(sources, suppressLogging = false) {
 		const path = source.path;
 		const resolvedPath = path.replace("$HOME", homedir());
 		const varName = `sources_${(source.name ?? basename(path, extname(resolvedPath))).replace(/\s+/g, "_")}`;
-		if (!suppressLogging) consola.info("Extra variable:", varName, resolvedPath);
+		if (!suppressLogging) consola.debug("Extra variable:", varName, resolvedPath);
 		return new ExtraVariable(varName, `'${resolvedPath}'`);
 	});
 }
@@ -2597,7 +2793,6 @@ async function writeGeneratedFile(projectDir, gen, generator, file, queries, tab
 	}
 	const outputPath = getOutputPath(projectDir, name, gen, generator);
 	writeFileSync(outputPath, sourceFile);
-	consola.success(`Generated ${outputPath}`);
 	await generator.afterGenerate(outputPath);
 	return outputPath;
 }
@@ -2671,12 +2866,24 @@ async function validateProject(projectPath) {
 	}
 	return await validateProjectFromConfig(project, projectDir);
 }
+/** Count enum types across queries */
+function countEnums(queries) {
+	const enumNames = /* @__PURE__ */ new Set();
+	for (const query of queries) {
+		if (!query.isQuery) continue;
+		for (const col of query.columns) if (col.type instanceof EnumType && col.type.name) enumNames.add(col.type.name);
+	}
+	return enumNames.size;
+}
 /**
 * Process a project configuration and generate code from a Project object
 */
-async function processProjectFromConfig(project, projectDir, writeToStdout = false) {
+async function processProjectFromConfig(project, projectDir, writeToStdout = false, ui) {
 	const originalLevel = consola.level;
 	if (writeToStdout) consola.level = LogLevels.silent;
+	const totalStart = performance.now();
+	const reporter = ui?.createReporter();
+	const results = [];
 	try {
 		const extraVariables = createExtraVariables(project.sources ?? [], writeToStdout);
 		const files = [];
@@ -2701,31 +2908,52 @@ async function processProjectFromConfig(project, projectDir, writeToStdout = fal
 					throw SqgError.inFile(`Failed to parse SQL file: ${e.message}`, "SQL_PARSE_ERROR", sqlFile, { suggestion: "Check SQL syntax and annotation format" });
 				}
 				for (const [engine, gens] of gensByEngine) {
+					const executableQueries = queries.filter((q) => !q.skipGenerateFunction);
+					const reporterAny = reporter;
+					if (reporterAny?.setQueryTotal) reporterAny.setQueryTotal(executableQueries.length);
 					try {
 						const dbEngine = getDatabaseEngine(engine);
-						await dbEngine.initializeDatabase(queries);
-						await dbEngine.executeQueries(queries);
-						if (tables.length > 0) await dbEngine.introspectTables(tables);
+						ui?.startPhase(`Initializing ${engine} database...`);
+						await dbEngine.initializeDatabase(queries, reporter);
+						ui?.startPhase(`Introspecting ${executableQueries.length} queries...`);
+						await dbEngine.executeQueries(queries, reporter);
+						if (tables.length > 0) await dbEngine.introspectTables(tables, reporter);
+						ui?.succeedPhase(`Introspected ${executableQueries.length} queries`);
 						validateQueries(queries);
 						await dbEngine.close();
 					} catch (e) {
+						ui?.failPhase(`Failed to process ${sqlFile}`);
 						if (e instanceof SqgError) throw e;
 						throw new SqgError(`Database error processing ${sqlFile}: ${e.message}`, "DATABASE_ERROR", `Check that the SQL is valid for engine '${engine}'`, {
 							file: sqlFile,
 							engine
 						});
 					}
+					ui?.startPhase("Generating code...");
+					const genStart = performance.now();
 					for (const gen of gens) {
 						const generator = getGenerator(gen.generator);
 						const outputPath = await writeGeneratedFile(projectDir, {
 							...gen,
 							projectName: project.name
 						}, generator, sqlFile, queries, tables, engine, writeToStdout);
-						if (outputPath !== null) files.push(outputPath);
+						if (outputPath !== null) {
+							files.push(outputPath);
+							results.push({
+								outputPath,
+								queryCount: executableQueries.length,
+								enumCount: countEnums(queries),
+								sqlFile,
+								generator: gen.generator,
+								elapsedMs: performance.now() - genStart
+							});
+						}
 					}
+					ui?.succeedPhase(`Generated ${gens.length} ${gens.length === 1 ? "file" : "files"} from ${sqlFile}`);
 				}
 			}
 		}
+		ui?.summary(results, performance.now() - totalStart);
 		return files;
 	} finally {
 		if (writeToStdout) consola.level = originalLevel;
@@ -2734,16 +2962,16 @@ async function processProjectFromConfig(project, projectDir, writeToStdout = fal
 /**
 * Process a project configuration and generate code from a YAML file
 */
-async function processProject(projectPath) {
+async function processProject(projectPath, ui) {
 	const projectDir = resolve(dirname(projectPath));
-	return await processProjectFromConfig(parseProjectConfig(projectPath), projectDir, false);
+	return await processProjectFromConfig(parseProjectConfig(projectPath), projectDir, false, ui);
 }
 
 //#endregion
 //#region src/mcp-server.ts
 const server = new Server({
 	name: "sqg-mcp",
-	version: process.env.npm_package_version ?? "0.11.0"
+	version: process.env.npm_package_version ?? "0.13.0"
 }, { capabilities: {
 	tools: {},
 	resources: {}
@@ -3070,11 +3298,154 @@ async function startMcpServer() {
 	console.error("SQG MCP server running on stdio");
 }
 
+//#endregion
+//#region src/ui.ts
+/**
+* SQG UI Module - Centralized terminal output with spinners, timing, and beautiful errors
+*/
+var UI = class {
+	spinner = null;
+	silent;
+	verbose;
+	phaseStart = 0;
+	version;
+	constructor(options) {
+		this.silent = options.format === "json" || options.isStdout === true;
+		this.verbose = options.verbose === true;
+		this.version = options.version || "";
+	}
+	/** Print colored header */
+	header() {
+		if (this.silent) return;
+		const logo = pc.bold(pc.blue("SQG"));
+		const ver = this.version ? ` ${pc.dim(`v${this.version}`)}` : "";
+		this.log(`\n ${logo}${ver}\n`);
+	}
+	/** Create a ProgressReporter for DB adapters */
+	createReporter() {
+		if (this.silent) return {};
+		let queryCount = 0;
+		let queryTotal = 0;
+		return {
+			onQueryStart: (id) => {
+				queryCount++;
+				if (this.verbose) this.log(`  ${pc.dim(`Executing query: ${id}`)}`);
+				else if (this.spinner) this.spinner.text = `Introspecting queries... (${queryCount}/${queryTotal || "?"})`;
+			},
+			onQueryComplete: (id) => {
+				if (this.verbose) this.log(`  ${pc.green("+")} ${pc.dim(id)}`);
+			},
+			onTableStart: (name) => {
+				if (this.verbose) this.log(`  ${pc.dim(`Introspecting table: ${name}`)}`);
+			},
+			onTableComplete: (name, columnCount) => {
+				if (this.verbose) this.log(`  ${pc.green("+")} ${pc.dim(`${name} (${columnCount} columns)`)}`);
+			},
+			onContainerStarting: () => {
+				this.startPhase("Starting PostgreSQL container...");
+			},
+			onContainerStarted: (_uri) => {
+				this.succeedPhase("PostgreSQL ready");
+			},
+			onDatabaseInitialized: () => {
+				if (this.verbose) this.log(`  ${pc.green("+")} ${pc.dim("Database initialized")}`);
+			},
+			setQueryTotal: (total) => {
+				queryTotal = total;
+				queryCount = 0;
+			}
+		};
+	}
+	/** Start a phase with a spinner */
+	startPhase(label) {
+		if (this.silent) return;
+		this.stopSpinner();
+		this.phaseStart = performance.now();
+		this.spinner = yoctoSpinner({ text: label }).start();
+	}
+	/** Complete a phase successfully */
+	succeedPhase(label) {
+		if (this.silent) return;
+		const elapsed = this.phaseStart ? performance.now() - this.phaseStart : 0;
+		const time = elapsed > 100 ? pc.dim(` (${formatMs(elapsed)})`) : "";
+		if (this.spinner) {
+			this.spinner.success(`${label}${time}`);
+			this.spinner = null;
+		} else this.log(`${pc.green("+")} ${label}${time}`);
+	}
+	/** Fail a phase */
+	failPhase(label) {
+		if (this.silent) return;
+		if (this.spinner) {
+			this.spinner.error(label);
+			this.spinner = null;
+		} else this.log(`${pc.red("x")} ${label}`);
+	}
+	/** Display generation summary */
+	summary(results, totalMs) {
+		if (this.silent || results.length === 0) return;
+		this.log("");
+		for (const r of results) {
+			const parts = [];
+			if (r.queryCount > 0) parts.push(`${r.queryCount} ${r.queryCount === 1 ? "query" : "queries"}`);
+			if (r.enumCount > 0) parts.push(`${r.enumCount} ${r.enumCount === 1 ? "enum" : "enums"}`);
+			this.log(`  ${pc.dim("->")} ${dimPath(r.outputPath)}  ${pc.dim(`(${parts.join(", ")})`)}`);
+		}
+		this.log("");
+		this.log(` ${pc.green("done")} ${pc.dim(`in ${formatMs(totalMs)}`)}`);
+	}
+	/** Display a formatted error */
+	error(err) {
+		if (this.silent) return;
+		this.stopSpinner();
+		const isSqg = "code" in err && "suggestion" in err;
+		const message = err.message;
+		const suggestion = isSqg ? err.suggestion : void 0;
+		const code = isSqg ? err.code : void 0;
+		this.log("");
+		this.log(` ${pc.red(pc.bold("ERROR"))}  ${message}`);
+		if (suggestion) {
+			this.log("");
+			this.log(`   ${pc.dim("Suggestion:")} ${suggestion}`);
+		}
+		if (code && this.verbose) this.log(`   ${pc.dim("Code:")} ${code}`);
+		this.log("");
+	}
+	stopSpinner() {
+		if (this.spinner) {
+			this.spinner.stop();
+			this.spinner = null;
+		}
+	}
+	log(msg) {
+		process.stderr.write(`${msg}\n`);
+	}
+};
+/** Format path with dim directory and bright filename, relative to cwd when it's a subpath */
+function dimPath(fullPath) {
+	const rel = relative(process.cwd(), fullPath);
+	const display = rel && !rel.startsWith("..") ? rel : fullPath;
+	const dir = dirname(display);
+	const file = basename(display);
+	if (dir === ".") return file;
+	return `${pc.dim(`${dir}/`)}${file}`;
+}
+/** Format milliseconds as human-readable */
+function formatMs(ms) {
+	if (ms < 1e3) return `${Math.round(ms)}ms`;
+	return `${(ms / 1e3).toFixed(1)}s`;
+}
+
 //#endregion
 //#region src/sqg.ts
-const version = process.env.npm_package_version ?? "0.11.0";
+const version = process.env.npm_package_version ?? "0.13.0";
+updateNotifier({ pkg: {
+	name: "@sqg/sqg",
+	version
+} }).notify({ message: "Update available {currentVersion} → {latestVersion}" });
 const description = process.env.npm_package_description ?? "SQG - SQL Query Generator - Type-safe code generation from SQL (https://sqg.dev)";
-consola.level = LogLevels.info;
+consola.level = LogLevels.warn;
+const BRANDING = `\n ${pc.bold(pc.blue("SQG"))} ${pc.dim(`v${version}`)}\n`;
 const program = new Command().name("sqg").description(`${description}
 
 Generate type-safe database access code from annotated SQL files.
@@ -3083,12 +3454,20 @@ Supported Generators:
 ${formatGeneratorsHelp()}`).version(version, "-v, --version", "output the version number").option("--verbose", "Enable debug logging (shows SQL execution details)").option("--format <format>", "Output format: text (default) or json", "text").option("--validate", "Validate configuration without generating code").option("--generator <generator>", `Code generation generator (${SHORT_GENERATOR_NAMES.join(", ")})`).option("--file <file>", "SQL file path (can be repeated)", (val, prev = []) => {
 	prev.push(val);
 	return prev;
-}).option("--output <path>", "Output file or directory path (optional, if omitted writes to stdout)").option("--name <name>", "Project name (optional, defaults to 'generated')").showHelpAfterError().showSuggestionAfterError();
+}).option("--output <path>", "Output file or directory path (optional, if omitted writes to stdout)").option("--name <name>", "Project name (optional, defaults to 'generated')").addHelpText("before", BRANDING).showHelpAfterError().showSuggestionAfterError();
 program.argument("[project]", "Path to the project YAML config (sqg.yaml) or omit to use CLI options").hook("preAction", (thisCommand) => {
 	const opts = thisCommand.opts();
 	if (opts.verbose) consola.level = LogLevels.debug;
 	if (opts.format === "json") consola.level = LogLevels.silent;
 }).action(async (projectPath, options) => {
+	const writeToStdout = !projectPath && !options.output;
+	const ui = new UI({
+		format: options.format,
+		verbose: options.verbose,
+		isStdout: writeToStdout,
+		version
+	});
+	ui.header();
 	try {
 		if (!projectPath) {
 			if (!options.generator) throw new SqgError("Missing required option: --generator", "CONFIG_VALIDATION_ERROR", `Specify a code generation generator: ${SHORT_GENERATOR_NAMES.join(", ")}`);
@@ -3100,7 +3479,6 @@ program.argument("[project]", "Path to the project YAML config (sqg.yaml) or omi
 				name: options.name
 			});
 			const projectDir = process.cwd();
-			const writeToStdout = !options.output;
 			if (options.validate) {
 				const result = await validateProjectFromConfig(project, projectDir);
 				if (options.format === "json") console.log(JSON.stringify(result, null, 2));
@@ -3118,7 +3496,7 @@ program.argument("[project]", "Path to the project YAML config (sqg.yaml) or omi
 				}
 				exit(result.valid ? 0 : 1);
 			}
-			const files = await processProjectFromConfig(project, projectDir, writeToStdout);
+			const files = await processProjectFromConfig(project, projectDir, writeToStdout, ui);
 			if (options.format === "json" && !writeToStdout) console.log(JSON.stringify({
 				status: "success",
 				generatedFiles: files
@@ -3141,7 +3519,7 @@ program.argument("[project]", "Path to the project YAML config (sqg.yaml) or omi
 				}
 				exit(result.valid ? 0 : 1);
 			}
-			const files = await processProject(projectPath);
+			const files = await processProject(projectPath, ui);
 			if (options.format === "json") console.log(JSON.stringify({
 				status: "success",
 				generatedFiles: files
@@ -3149,15 +3527,13 @@ program.argument("[project]", "Path to the project YAML config (sqg.yaml) or omi
 		}
 	} catch (err) {
 		if (options.format === "json") console.log(JSON.stringify(formatErrorForOutput(err)));
-		else if (err instanceof SqgError) {
-			consola.error(err.message);
-			if (err.suggestion) consola.info(`Suggestion: ${err.suggestion}`);
-			if (err.context && options.verbose) consola.debug("Context:", err.context);
-		} else consola.error(err);
+		else if (err instanceof SqgError) ui.error(err);
+		else if (err instanceof Error) ui.error(err);
+		else consola.error(err);
 		exit(1);
 	}
 });
-program.command("init").description("Initialize a new SQG project with example configuration").option("-t, --generator <generator>", `Code generation generator (${SHORT_GENERATOR_NAMES.join(", ")})`, "typescript/sqlite").option("-o, --output <dir>", "Output directory for generated files", "./generated").option("-f, --force", "Overwrite existing files").action(async (options) => {
+program.command("init").description("Initialize a new SQG project with example configuration").option("-t, --generator <generator>", `Code generation generator (${SHORT_GENERATOR_NAMES.join(", ")}). Omit for interactive mode`).option("-o, --output <dir>", "Output directory for generated files", "./generated").option("-f, --force", "Overwrite existing files").action(async (options) => {
 	const parentOpts = program.opts();
 	try {
 		await initProject(options);
@@ -3167,10 +3543,15 @@ program.command("init").description("Initialize a new SQG project with example c
 		}));
 	} catch (err) {
 		if (parentOpts.format === "json") console.log(JSON.stringify(formatErrorForOutput(err)));
-		else if (err instanceof SqgError) {
-			consola.error(err.message);
-			if (err.suggestion) consola.info(`Suggestion: ${err.suggestion}`);
-		} else consola.error(err);
+		else {
+			const ui = new UI({
+				format: parentOpts.format,
+				verbose: parentOpts.verbose
+			});
+			if (err instanceof SqgError) ui.error(err);
+			else if (err instanceof Error) ui.error(err);
+			else consola.error(err);
+		}
 		exit(1);
 	}
 });

package/dist/templates/java-jdbc.hbs

@@ -201,6 +201,8 @@ public class {{className}} {
     }
 {{/if}}
 
+    {{{declareEnums queries}}}
+
     {{#each queries}}
     {{#unless skipGenerateFunction}}
     {{>columnTypesRecord}}
@@ -213,6 +215,7 @@ public class {{className}} {
     public Stream<{{rowType}}> {{functionName}}Stream({{#each variables}}{{{type}}} {{name}}{{#unless @last}}, {{/unless}}{{/each}}) throws SQLException {
         var stmt = connection.prepareStatement({{{partsToString sqlQueryParts}}});
         {{#each parameters}}{{#if isArray}}stmt.setArray({{plusOne @index}}, connection.createArrayOf("{{arrayBaseType}}", {{name}}.toArray()));
+        {{else if isEnum}}stmt.setObject({{plusOne @index}}, {{name}}.getValue());
         {{else}}stmt.setObject({{plusOne @index}}, {{name}});
         {{/if}}{{/each}}
         var rs = stmt.executeQuery();
@@ -329,6 +332,7 @@ int
 
 {{#*inline "execute"}}
 {{#each parameters}}{{#if isArray}}stmt.setArray({{plusOne @index}}, connection.createArrayOf("{{arrayBaseType}}", {{name}}.toArray()));
+{{else if isEnum}}stmt.setObject({{plusOne @index}}, {{name}}.getValue());
 {{else}}stmt.setObject({{plusOne @index}}, {{name}});
 {{/if}}{{/each}}
 {{#if isQuery}}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sqg/sqg",
-  "version": "0.11.0",
+  "version": "0.13.0",
   "description": "SQG - SQL Query Generator - Type-safe code generation from SQL (https://sqg.dev)",
   "type": "module",
   "bin": {
@@ -39,12 +39,15 @@
   "license": "Apache-2.0",
   "dependencies": {
     "@biomejs/biome": "2.3.3",
+    "@clack/prompts": "^1.1.0",
     "@duckdb/node-api": "1.4.3-r.2",
     "@duckdb/node-bindings-linux-x64": "1.4.3-r.2",
     "@lezer-unofficial/printer": "^1.0.1",
     "@lezer/common": "^1.5.0",
     "@lezer/generator": "^1.8.0",
     "@lezer/lr": "^1.4.6",
+    "@modelcontextprotocol/sdk": "^1.0.4",
+    "@testcontainers/postgresql": "^10.21.0",
     "better-sqlite3": "^12.5.0",
     "commander": "^14.0.2",
     "consola": "^3.4.2",
@@ -53,12 +56,13 @@
     "handlebars": "^4.7.8",
     "pg": "^8.16.3",
     "pg-types": "^4.1.0",
-    "@testcontainers/postgresql": "^10.21.0",
+    "picocolors": "^1.1.1",
     "prettier": "^3.7.4",
     "prettier-plugin-java": "^2.7.7",
+    "update-notifier": "^7.3.1",
     "yaml": "^2.8.2",
-    "zod": "^4.3.5",
-    "@modelcontextprotocol/sdk": "^1.0.4"
+    "yocto-spinner": "^1.1.0",
+    "zod": "^4.3.5"
   },
   "devDependencies": {
     "@libsql/client": "^0.17.0",
@@ -66,6 +70,7 @@
     "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^25.0.3",
     "@types/pg": "^8.16.0",
+    "@types/update-notifier": "^6.0.8",
     "@vitest/ui": "^4.0.16",
     "tsdown": "0.18.0",
     "tsx": "^4.21.0",