@elyracode/db-tools 0.4.9 → 0.5.1

package/README.md

@@ -61,7 +61,17 @@ export ELYRA_CLICKHOUSE_TIMEOUT_QUERY=30000
 |------|-------------|
 | `query_mysql` | Execute SQL against MySQL. Results returned as JSON. |
 | `query_clickhouse` | Execute SQL against ClickHouse. Optimized for analytical queries on large datasets. |
-| `get_database_schema` | Discover tables, columns, types, and indexes. The agent calls this before writing queries. |
+| `query_sqlite` | Execute SQL against SQLite. Auto-detects Laravel SQLite databases from .env. |
+| `get_database_schema` | Discover tables, columns, types, and indexes. Supports MySQL, ClickHouse, and SQLite. |
+
+### SQLite
+
+SQLite is auto-detected from your project:
+1. If `.env` has `DB_CONNECTION=sqlite`, uses `DB_DATABASE` path
+2. Falls back to `database/database.sqlite` (Laravel default)
+3. Or pass an explicit path: the agent uses `db_path` parameter
+
+No configuration needed for most Laravel projects.
 
 ## Security
 

package/extensions/index.ts

@@ -175,6 +175,76 @@ export default function (elyra: ExtensionAPI) {
 		},
 	});
 
+	// ── Tool: query_sqlite ──
+	elyra.registerTool({
+		name: "query_sqlite",
+		label: "Query SQLite",
+		description:
+			"Execute a SQL query against an SQLite database file. Returns results as JSON. " +
+			"Use get_database_schema first to understand the database structure. " +
+			"By default, only SELECT queries are allowed. " +
+			"Auto-detects Laravel SQLite databases from .env (DB_CONNECTION=sqlite).",
+		parameters: Type.Object({
+			sql: Type.String({ description: "The SQL query to execute" }),
+			db_path: Type.Optional(
+				Type.String({ description: "Path to the SQLite database file (default: auto-detect from .env or database/database.sqlite)" }),
+			),
+		}),
+		execute: async (_toolCallId, params) => {
+			const dbPath = resolveSqlitePath(params.db_path);
+			if (!dbPath) {
+				return {
+					content: [{
+						type: "text",
+						text: "SQLite database not found. Provide db_path or set DB_CONNECTION=sqlite in .env.",
+					}],
+					details: {},
+				};
+			}
+
+			if (!isReadOnly(params.sql) && !isWriteEnabled()) {
+				return {
+					content: [{
+						type: "text",
+						text: `Blocked: Only SELECT queries are allowed in read-only mode. Set ELYRA_DB_ALLOW_WRITES=true to enable writes.\n\nQuery: ${params.sql}`,
+					}],
+					details: {},
+				};
+			}
+
+			try {
+				const { execSync } = await import("node:child_process");
+				const result = execSync(
+					`sqlite3 -json "${dbPath}" "${params.sql.replace(/"/g, '\\"')}"`,
+					{ timeout: 30000, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] },
+				);
+
+				const trimmed = result.trim();
+				if (!trimmed) {
+					return {
+						content: [{ type: "text", text: "Query executed successfully (no results)." }],
+						details: { rowCount: 0 },
+					};
+				}
+
+				const truncated = trimmed.length > 50000
+					? `${trimmed.slice(0, 50000)}\n\n... (truncated, ${trimmed.length} chars total)`
+					: trimmed;
+
+				return {
+					content: [{ type: "text", text: truncated }],
+					details: {},
+				};
+			} catch (error) {
+				const msg = error instanceof Error ? error.message : String(error);
+				return {
+					content: [{ type: "text", text: `SQLite error: ${msg}` }],
+					details: {},
+				};
+			}
+		},
+	});
+
 	// ── Tool: get_database_schema ──
 	elyra.registerTool({
 		name: "get_database_schema",
@@ -182,9 +252,9 @@ export default function (elyra: ExtensionAPI) {
 		description:
 			"Discover the database schema (tables, columns, types, indexes). " +
 			"Call this before writing queries to understand the database structure. " +
-			"Supports both MySQL and ClickHouse.",
+			"Supports MySQL, ClickHouse, and SQLite.",
 		parameters: Type.Object({
-			engine: Type.Union([Type.Literal("mysql"), Type.Literal("clickhouse")], {
+			engine: Type.Union([Type.Literal("mysql"), Type.Literal("clickhouse"), Type.Literal("sqlite")], {
 				description: "Which database engine to query",
 			}),
 			database: Type.Optional(
@@ -197,10 +267,13 @@ export default function (elyra: ExtensionAPI) {
 				}),
 			),
 		}),
-		execute: async (toolCallId, params, ctx) => {
+		execute: async (_toolCallId, params) => {
 			if (params.engine === "mysql") {
 				return getMysqlSchema(params.database, params.table);
 			}
+			if (params.engine === "sqlite") {
+				return getSqliteSchema(params.database, params.table);
+			}
 			return getClickHouseSchema(params.database, params.table);
 		},
 	});
@@ -480,3 +553,85 @@ async function getClickHouseSchema(
 		};
 	}
 }
+
+// ── SQLite Helpers ──
+
+function resolveSqlitePath(explicitPath?: string): string | undefined {
+	if (explicitPath) {
+		const resolved = explicitPath.startsWith("/") ? explicitPath : join(process.cwd(), explicitPath);
+		return existsSync(resolved) ? resolved : undefined;
+	}
+
+	// Auto-detect from .env
+	const cwd = process.cwd();
+	const envPath = join(cwd, ".env");
+	if (existsSync(envPath)) {
+		const parsed = parseEnvFile(readFileSync(envPath, "utf-8"));
+		if (parsed.DB_CONNECTION === "sqlite") {
+			const dbDatabase = parsed.DB_DATABASE;
+			if (dbDatabase) {
+				const resolved = dbDatabase.startsWith("/") ? dbDatabase : join(cwd, dbDatabase);
+				if (existsSync(resolved)) return resolved;
+			}
+		}
+	}
+
+	// Laravel default
+	const laravelDefault = join(cwd, "database", "database.sqlite");
+	if (existsSync(laravelDefault)) return laravelDefault;
+
+	return undefined;
+}
+
+function getSqliteSchema(
+	dbPathOverride?: string,
+	table?: string,
+): { content: Array<{ type: "text"; text: string }>; details: Record<string, unknown> } {
+	const dbPath = resolveSqlitePath(dbPathOverride);
+	if (!dbPath) {
+		return {
+			content: [{ type: "text", text: "SQLite database not found." }],
+			details: {},
+		};
+	}
+
+	try {
+		const { execSync } = require("node:child_process");
+
+		if (table) {
+			const columns = execSync(
+				`sqlite3 -json "${dbPath}" "PRAGMA table_info('${table}')"`,
+				{ timeout: 10000, encoding: "utf-8" },
+			);
+			const indexes = execSync(
+				`sqlite3 -json "${dbPath}" "PRAGMA index_list('${table}')"`,
+				{ timeout: 10000, encoding: "utf-8" },
+			);
+			return {
+				content: [{
+					type: "text",
+					text: `Table: ${table}\n\nColumns:\n${columns.trim()}\n\nIndexes:\n${indexes.trim()}`,
+				}],
+				details: {},
+			};
+		}
+
+		const tables = execSync(
+			`sqlite3 -json "${dbPath}" "SELECT name, type FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' ORDER BY name"`,
+			{ timeout: 10000, encoding: "utf-8" },
+		);
+		return {
+			content: [{
+				type: "text",
+				text: `Database: ${dbPath}\n\nTables:\n${tables.trim()}`,
+			}],
+			details: {},
+		};
+	} catch (error) {
+		const msg = error instanceof Error ? error.message : String(error);
+		return {
+			content: [{ type: "text", text: `SQLite schema error: ${msg}` }],
+			details: {},
+		};
+	}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elyracode/db-tools",
-  "version": "0.4.9",
+  "version": "0.5.1",
     "description": "Database tools for Elyra - query MySQL and ClickHouse with schema awareness and safety guardrails",
   "type": "module",
   "keywords": [