@fragno-dev/cli 0.1.1 → 0.1.3

package/.turbo/turbo-build.log

@@ -7,9 +7,9 @@ $ tsdown
 ℹ Build start
 ℹ Granting execute permission to dist/cli.d.ts
 ℹ Granting execute permission to dist/cli.js
-ℹ dist/cli.js        16.07 kB │ gzip: 3.50 kB
-ℹ dist/cli.js.map    30.92 kB │ gzip: 6.79 kB
-ℹ dist/cli.d.ts.map   0.23 kB │ gzip: 0.19 kB
-ℹ dist/cli.d.ts       0.39 kB │ gzip: 0.19 kB
-ℹ 4 files, total: 47.61 kB
-✔ Build complete in 10597ms
+ℹ dist/cli.js        16.59 kB │ gzip: 3.65 kB
+ℹ dist/cli.js.map    33.18 kB │ gzip: 7.26 kB
+ℹ dist/cli.d.ts.map   0.51 kB │ gzip: 0.30 kB
+ℹ dist/cli.d.ts       0.94 kB │ gzip: 0.30 kB
+ℹ 4 files, total: 51.22 kB
+✔ Build complete in 15136ms

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # @fragno-dev/cli
 
+## 0.1.3
+
+### Patch Changes
+
+- a8b1f81: `db generate` command now supports targeting multiple Fragment files
+- a8b1f81: `db info` command now supports targeting multiple files
+- be17727: Added support for generating migrations in multi-Fragment applications
+- Updated dependencies [e7122f2]
+- Updated dependencies [921ef11]
+- Updated dependencies [be17727]
+- Updated dependencies [8362d9a]
+- Updated dependencies [8362d9a]
+- Updated dependencies [c70de59]
+  - @fragno-dev/db@0.1.2
+  - @fragno-dev/core@0.1.2
+
+## 0.1.2
+
+### Patch Changes
+
+- Updated dependencies [4c1c806]
+  - @fragno-dev/db@0.1.1
+  - @fragno-dev/core@0.1.1
+
 ## 0.1.1
 
 ### Patch Changes

package/dist/cli.d.ts

@@ -1,12 +1,39 @@
 #!/usr/bin/env node
-import { Command } from "gunshi";
+import * as gunshi4 from "gunshi";
 
+//#region src/commands/db/generate.d.ts
+declare const generateCommand: gunshi4.Command<{
+  output: {
+    type: "string";
+    short: string;
+    description: string;
+  };
+  from: {
+    type: "number";
+    short: string;
+    description: string;
+  };
+  to: {
+    type: "number";
+    short: string;
+    description: string;
+  };
+  prefix: {
+    type: "string";
+    short: string;
+    description: string;
+  };
+}>;
+//#endregion
+//#region src/commands/db/migrate.d.ts
+declare const migrateCommand: gunshi4.Command<{}>;
+//#endregion
+//#region src/commands/db/info.d.ts
+declare const infoCommand: gunshi4.Command<{}>;
+//#endregion
 //#region src/cli.d.ts
-declare const generateCommand: Command;
-declare const migrateCommand: Command;
-declare const infoCommand: Command;
-declare const dbCommand: Command;
-declare const mainCommand: Command;
+declare const dbCommand: gunshi4.Command<gunshi4.Args>;
+declare const mainCommand: gunshi4.Command<gunshi4.Args>;
 //#endregion
 export { dbCommand, generateCommand, infoCommand, mainCommand, migrateCommand };
 //# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.d.ts","names":[],"sources":["../src/cli.ts"],"sourcesContent":[],"mappings":";;;;cAQa,iBAAiB;cAkCjB,gBAAgB;AAlChB,cAyDA,WA1BZ,EA0ByB,OA1BzB;AAGY,cAwDA,SApCZ,EAoCuB,OAxDK;AAuBhB,cA4CA,WA5Ca,EA4CA,OAlCzB"}
+{"version":3,"file":"cli.d.ts","names":[],"sources":["../src/commands/db/generate.ts","../src/commands/db/migrate.ts","../src/commands/db/info.ts","../src/cli.ts"],"sourcesContent":[],"mappings":";;;;cASa,iBAqKX,OAAA,CArK0B;;;;IAAf,WAAA,EAAA,MAqKX;;;;ICvKW,KAAA,EAAA,MA6HX;;;;IC9HW,IAAA,EAAA,QA2KX;;;;ECrJW,MAAA,EAAA;IAWA,IAAA,EAAA,QAaX;;;;;;;cF7CW,gBA6HX,OAAA,CA7HyB;;;cCDd,aA2KX,OAAA,CA3KsB;;;AFGX,cGmBA,SHkJX,EGlJoB,OAAA,CAAA,OHnBM,CGuB1B,OAAA,CAJoB,IAAA,CHnBM;cG8Bf,aAAW,OAAA,CAAA,QAatB,OAAA,CAbsB,IAAA"}

package/dist/cli.js

@@ -1,9 +1,10 @@
 #!/usr/bin/env node
-import { cli, parseArgs, resolveArgs } from "gunshi";
-import { mkdir, stat, writeFile } from "node:fs/promises";
-import { basename, dirname, join, resolve } from "node:path";
+import { cli, define, parseArgs, resolveArgs } from "gunshi";
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
 import { FragnoDatabase, isFragnoDatabase } from "@fragno-dev/db";
 import { instantiatedFragmentFakeSymbol } from "@fragno-dev/core/api/fragment-instantiation";
+import { executeMigrations, generateMigrationsOrSchema } from "@fragno-dev/db/generation-engine";
 
 //#region src/utils/find-fragno-databases.ts
 function isFragnoInstantiatedFragment(value) {
@@ -40,210 +41,22 @@ function findFragnoDatabases(targetModule) {
 
 //#endregion
 //#region src/commands/db/generate.ts
-async function generate(ctx) {
-	const target = ctx.values["target"];
-	const output = ctx.values["output"];
-	const toVersion = ctx.values["to"];
-	const fromVersion = ctx.values["from"];
-	const prefix = ctx.values["prefix"];
-	if (!target || typeof target !== "string") throw new Error("Target file path is required and must be a string");
-	if (typeof output === "number" || typeof output === "boolean") throw new Error("Output file path is required and must be a string");
-	if (toVersion !== void 0 && typeof toVersion !== "string" && typeof toVersion !== "number") throw new Error("Version must be a number or string");
-	if (fromVersion !== void 0 && typeof fromVersion !== "string" && typeof fromVersion !== "number") throw new Error("Version must be a number or string");
-	if (prefix !== void 0 && typeof prefix !== "string") throw new Error("Prefix must be a string");
-	const targetPath = resolve(process.cwd(), target);
-	console.log(`Loading target file: ${targetPath}`);
-	let targetModule;
-	try {
-		targetModule = await import(targetPath);
-	} catch (error) {
-		throw new Error(`Failed to import target file: ${error instanceof Error ? error.message : String(error)}`);
-	}
-	const fragnoDatabases = findFragnoDatabases(targetModule);
-	if (fragnoDatabases.length === 0) throw new Error(`No FragnoDatabase instances found in ${target}.\nMake sure you export either:\n  - A FragnoDatabase instance created with .create(adapter)\n  - An instantiated fragment with embedded database definition\n`);
-	if (fragnoDatabases.length > 1) console.warn(`Warning: Multiple FragnoDatabase instances found (${fragnoDatabases.length}). Using the first one.`);
-	const fragnoDb = fragnoDatabases[0];
-	const targetVersion = toVersion !== void 0 ? parseInt(String(toVersion), 10) : void 0;
-	const sourceVersion = fromVersion !== void 0 ? parseInt(String(fromVersion), 10) : void 0;
-	if (targetVersion !== void 0 && isNaN(targetVersion)) throw new Error(`Invalid version number: ${toVersion}`);
-	if (sourceVersion !== void 0 && isNaN(sourceVersion)) throw new Error(`Invalid version number: ${fromVersion}`);
-	if (sourceVersion !== void 0 && targetVersion !== void 0) console.log(`Generating schema for namespace: ${fragnoDb.namespace} (from version ${sourceVersion} to version ${targetVersion})`);
-	else if (targetVersion !== void 0) console.log(`Generating schema for namespace: ${fragnoDb.namespace} (to version ${targetVersion})`);
-	else if (sourceVersion !== void 0) console.log(`Generating schema for namespace: ${fragnoDb.namespace} (from version ${sourceVersion})`);
-	else console.log(`Generating schema for namespace: ${fragnoDb.namespace}`);
-	let isDirectory = false;
-	if (output) {
-		const resolvedOutput = resolve(process.cwd(), output);
-		try {
-			isDirectory = (await stat(resolvedOutput)).isDirectory();
-		} catch {
-			isDirectory = output.endsWith("/");
-		}
-	}
-	let result;
-	try {
-		result = await fragnoDb.generateSchema({
-			path: isDirectory ? void 0 : output,
-			toVersion: targetVersion,
-			fromVersion: sourceVersion
-		});
-	} catch (error) {
-		throw new Error(`Failed to generate schema: ${error instanceof Error ? error.message : String(error)}`);
-	}
-	let finalOutputPath;
-	if (isDirectory && output) finalOutputPath = join(resolve(process.cwd(), output), basename(result.path));
-	else if (output) finalOutputPath = resolve(process.cwd(), output);
-	else finalOutputPath = resolve(process.cwd(), result.path);
-	const parentDir = dirname(finalOutputPath);
-	try {
-		await mkdir(parentDir, { recursive: true });
-	} catch (error) {
-		throw new Error(`Failed to create directory: ${error instanceof Error ? error.message : String(error)}`);
-	}
-	try {
-		const content = prefix ? `${prefix}\n${result.schema}` : result.schema;
-		await writeFile(finalOutputPath, content, { encoding: "utf-8" });
-	} catch (error) {
-		throw new Error(`Failed to write schema file: ${error instanceof Error ? error.message : String(error)}`);
-	}
-	console.log(`✓ Schema generated successfully: ${finalOutputPath}`);
-	console.log(`  Namespace: ${fragnoDb.namespace}`);
-	console.log(`  Schema version: ${fragnoDb.schema.version}`);
-}
-
-//#endregion
-//#region src/commands/db/migrate.ts
-async function migrate(ctx) {
-	const target = ctx.values["target"];
-	const version = ctx.values["to"];
-	const fromVersion = ctx.values["from"];
-	if (!target || typeof target !== "string") throw new Error("Target file path is required and must be a string");
-	if (version !== void 0 && typeof version !== "string" && typeof version !== "number") throw new Error("Version must be a number or string");
-	if (fromVersion !== void 0 && typeof fromVersion !== "string" && typeof fromVersion !== "number") throw new Error("Version must be a number or string");
-	const targetPath = resolve(process.cwd(), target);
-	console.log(`Loading target file: ${targetPath}`);
-	let targetModule;
-	try {
-		targetModule = await import(targetPath);
-	} catch (error) {
-		throw new Error(`Failed to import target file: ${error instanceof Error ? error.message : String(error)}`);
-	}
-	const fragnoDatabases = findFragnoDatabases(targetModule);
-	if (fragnoDatabases.length === 0) throw new Error(`No FragnoDatabase instances found in ${target}.\nMake sure you export either:\n  - A FragnoDatabase instance created with .create(adapter)\n  - An instantiated fragment with embedded database definition\n`);
-	if (fragnoDatabases.length > 1) console.warn(`Warning: Multiple FragnoDatabase instances found (${fragnoDatabases.length}). Using the first one.`);
-	const fragnoDb = fragnoDatabases[0];
-	console.log(`Migrating database for namespace: ${fragnoDb.namespace}`);
-	if (!fragnoDb.adapter.createMigrationEngine) throw new Error("Adapter does not support running migrations. The adapter only supports schema generation.\nTry using 'fragno db generate' instead to generate schema files.");
-	const targetVersion = version !== void 0 ? parseInt(String(version), 10) : void 0;
-	const expectedFromVersion = fromVersion !== void 0 ? parseInt(String(fromVersion), 10) : void 0;
-	if (targetVersion !== void 0 && isNaN(targetVersion)) throw new Error(`Invalid version number: ${version}`);
-	if (expectedFromVersion !== void 0 && isNaN(expectedFromVersion)) throw new Error(`Invalid version number: ${fromVersion}`);
-	let didMigrate;
-	try {
-		if (targetVersion !== void 0) {
-			console.log(`Migrating to version ${targetVersion}...`);
-			const migrator = fragnoDb.adapter.createMigrationEngine(fragnoDb.schema, fragnoDb.namespace);
-			const currentVersion = await migrator.getVersion();
-			console.log(`Current version: ${currentVersion}`);
-			if (expectedFromVersion !== void 0 && currentVersion !== expectedFromVersion) throw new Error(`Current database version (${currentVersion}) does not match expected --from version (${expectedFromVersion})`);
-			const preparedMigration = await migrator.prepareMigrationTo(targetVersion, { updateSettings: true });
-			if (preparedMigration.operations.length === 0) {
-				console.log("✓ Database is already at the target version. No migrations needed.");
-				didMigrate = false;
-			} else {
-				await preparedMigration.execute();
-				didMigrate = true;
-			}
-		} else {
-			console.log(`Migrating to latest version (${fragnoDb.schema.version})...`);
-			didMigrate = await fragnoDb.runMigrations();
-		}
-	} catch (error) {
-		throw new Error(`Failed to run migrations: ${error instanceof Error ? error.message : String(error)}`);
-	}
-	if (didMigrate) {
-		console.log(`✓ Migration completed successfully`);
-		console.log(`  Namespace: ${fragnoDb.namespace}`);
-		if (targetVersion !== void 0) console.log(`  New version: ${targetVersion}`);
-		else console.log(`  New version: ${fragnoDb.schema.version}`);
-	}
-}
-
-//#endregion
-//#region src/commands/db/info.ts
-async function info(ctx) {
-	const target = ctx.values["target"];
-	if (!target || typeof target !== "string") throw new Error("Target file path is required and must be a string");
-	const targetPath = resolve(process.cwd(), target);
-	console.log(`Loading target file: ${targetPath}`);
-	let targetModule;
-	try {
-		targetModule = await import(targetPath);
-	} catch (error) {
-		throw new Error(`Failed to import target file: ${error instanceof Error ? error.message : String(error)}`);
-	}
-	const fragnoDatabases = [];
-	for (const [key, value] of Object.entries(targetModule)) if (isFragnoDatabase(value)) {
-		fragnoDatabases.push(value);
-		console.log(`Found FragnoDatabase instance: ${key}`);
-	}
-	if (fragnoDatabases.length === 0) throw new Error(`No FragnoDatabase instances found in ${target}.\n`);
-	if (fragnoDatabases.length > 1) console.warn(`Warning: Multiple FragnoDatabase instances found (${fragnoDatabases.length}). Using the first one.`);
-	const fragnoDb = fragnoDatabases[0];
-	console.log("");
-	console.log("Database Information");
-	console.log("=".repeat(50));
-	console.log(`Namespace: ${fragnoDb.namespace}`);
-	console.log(`Latest Schema Version: ${fragnoDb.schema.version}`);
-	if (!fragnoDb.adapter.createMigrationEngine) {
-		console.log(`Migration Support: No`);
-		console.log("");
-		console.log("Note: This adapter does not support running migrations.");
-		console.log("Use 'fragno db generate' to generate schema files.");
-		return;
-	}
-	console.log(`Migration Support: Yes`);
-	try {
-		const currentVersion = await fragnoDb.adapter.createMigrationEngine(fragnoDb.schema, fragnoDb.namespace).getVersion();
-		console.log(`Current Database Version: ${currentVersion}`);
-		const pendingVersions = fragnoDb.schema.version - currentVersion;
-		if (pendingVersions > 0) {
-			console.log("");
-			console.log(`⚠ Pending Migrations: ${pendingVersions} version(s) behind`);
-			console.log(`  Run '@fragno-dev/cli db migrate --target ${target}' to update`);
-		} else if (pendingVersions === 0) {
-			console.log("");
-			console.log(`✓ Database is up to date`);
-		}
-	} catch (error) {
-		console.log("");
-		console.log(`Warning: Could not retrieve current version: ${error instanceof Error ? error.message : String(error)}`);
-	}
-	console.log("=".repeat(50));
-}
-
-//#endregion
-//#region src/cli.ts
-const generateCommand = {
+const generateCommand = define({
 	name: "generate",
 	description: "Generate schema files from FragnoDatabase definitions",
 	args: {
-		target: {
-			type: "positional",
-			description: "Path to the file that exports a FragnoDatabase instance"
-		},
 		output: {
 			type: "string",
 			short: "o",
-			description: "Output path for the generated schema file (default: schema.sql for Kysely, schema.ts for Drizzle)"
+			description: "Output path: for single file, exact file path; for multiple files, output directory (default: current directory)"
 		},
 		from: {
-			type: "string",
+			type: "number",
 			short: "f",
 			description: "Source version to generate migration from (default: current database version)"
 		},
 		to: {
-			type: "string",
+			type: "number",
 			short: "t",
 			description: "Target version to generate migration to (default: latest schema version)"
 		},
@@ -253,38 +66,210 @@ const generateCommand = {
 			description: "String to prepend to the generated file (e.g., '/* eslint-disable */')"
 		}
 	},
-	run: generate
-};
-const migrateCommand = {
+	run: async (ctx) => {
+		const targets = ctx.positionals;
+		const output = ctx.values.output;
+		const toVersion = ctx.values.to;
+		const fromVersion = ctx.values.from;
+		const prefix = ctx.values.prefix;
+		const uniqueTargets = Array.from(new Set(targets));
+		const allFragnoDatabases = [];
+		for (const target of uniqueTargets) {
+			const targetPath = resolve(process.cwd(), target);
+			console.log(`Loading target file: ${targetPath}`);
+			let targetModule;
+			try {
+				targetModule = await import(targetPath);
+			} catch (error) {
+				throw new Error(`Failed to import target file ${target}: ${error instanceof Error ? error.message : String(error)}`);
+			}
+			const fragnoDatabases = findFragnoDatabases(targetModule);
+			if (fragnoDatabases.length === 0) {
+				console.warn(`Warning: No FragnoDatabase instances found in ${target}.\nMake sure you export either:\n  - A FragnoDatabase instance created with .create(adapter)\n  - An instantiated fragment with embedded database definition\n`);
+				continue;
+			}
+			if (fragnoDatabases.length > 1) console.warn(`Warning: Multiple FragnoDatabase instances found in ${target} (${fragnoDatabases.length}). Using all of them.`);
+			allFragnoDatabases.push(...fragnoDatabases);
+		}
+		if (allFragnoDatabases.length === 0) throw new Error("No FragnoDatabase instances found in any of the target files.\nMake sure your files export either:\n  - A FragnoDatabase instance created with .create(adapter)\n  - An instantiated fragment with embedded database definition\n");
+		console.log(`Found ${allFragnoDatabases.length} FragnoDatabase instance(s) across ${uniqueTargets.length} file(s)`);
+		const firstDb = allFragnoDatabases[0];
+		const firstAdapter = firstDb.adapter;
+		if (!allFragnoDatabases.every((db) => db.adapter === firstAdapter)) throw new Error("All fragments must use the same database adapter instance. Mixed adapters are not supported.");
+		if (!firstDb.adapter.createSchemaGenerator && !firstDb.adapter.createMigrationEngine) throw new Error("The adapter does not support schema generation. Please use an adapter that implements either createSchemaGenerator or createMigrationEngine.");
+		console.log("Generating schema...");
+		let results;
+		try {
+			results = await generateMigrationsOrSchema(allFragnoDatabases, {
+				path: output,
+				toVersion,
+				fromVersion
+			});
+		} catch (error) {
+			throw new Error(`Failed to generate schema: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		for (const result of results) {
+			const finalOutputPath = output && results.length === 1 ? resolve(process.cwd(), output) : output ? resolve(process.cwd(), output, result.path) : resolve(process.cwd(), result.path);
+			const parentDir = dirname(finalOutputPath);
+			try {
+				await mkdir(parentDir, { recursive: true });
+			} catch (error) {
+				throw new Error(`Failed to create directory: ${error instanceof Error ? error.message : String(error)}`);
+			}
+			try {
+				await writeFile(finalOutputPath, prefix ? `${prefix}\n${result.schema}` : result.schema, { encoding: "utf-8" });
+			} catch (error) {
+				throw new Error(`Failed to write schema file: ${error instanceof Error ? error.message : String(error)}`);
+			}
+			console.log(`✓ Generated: ${finalOutputPath}`);
+		}
+		console.log(`\n✓ Schema generated successfully!`);
+		console.log(`  Files generated: ${results.length}`);
+		console.log(`  Fragments:`);
+		for (const db of allFragnoDatabases) console.log(`    - ${db.namespace} (version ${db.schema.version})`);
+	}
+});
+
+//#endregion
+//#region src/commands/db/migrate.ts
+const migrateCommand = define({
 	name: "migrate",
-	description: "Run database migrations",
-	args: {
-		target: {
-			type: "positional",
-			description: "Path to the file that exports a FragnoDatabase instance"
-		},
-		from: {
-			type: "string",
-			short: "f",
-			description: "Expected current database version (validates before migrating)"
-		},
-		to: {
-			type: "string",
-			short: "t",
-			description: "Target version to migrate to (default: latest schema version)"
+	description: "Run database migrations for all fragments to their latest versions",
+	args: {},
+	run: async (ctx) => {
+		const targets = ctx.positionals;
+		if (targets.length === 0) throw new Error("At least one target file path is required");
+		const uniqueTargets = Array.from(new Set(targets));
+		const allFragnoDatabases = [];
+		for (const target of uniqueTargets) {
+			const targetPath = resolve(process.cwd(), target);
+			console.log(`Loading target file: ${targetPath}`);
+			let targetModule;
+			try {
+				targetModule = await import(targetPath);
+			} catch (error) {
+				throw new Error(`Failed to import target file ${target}: ${error instanceof Error ? error.message : String(error)}`);
+			}
+			const fragnoDatabases = findFragnoDatabases(targetModule);
+			if (fragnoDatabases.length === 0) {
+				console.warn(`Warning: No FragnoDatabase instances found in ${target}.\nMake sure you export either:\n  - A FragnoDatabase instance created with .create(adapter)\n  - An instantiated fragment with embedded database definition\n`);
+				continue;
+			}
+			if (fragnoDatabases.length > 1) console.warn(`Warning: Multiple FragnoDatabase instances found in ${target} (${fragnoDatabases.length}). Using all of them.`);
+			allFragnoDatabases.push(...fragnoDatabases);
 		}
-	},
-	run: migrate
-};
-const infoCommand = {
+		if (allFragnoDatabases.length === 0) throw new Error("No FragnoDatabase instances found in any of the target files.\nMake sure your files export either:\n  - A FragnoDatabase instance created with .create(adapter)\n  - An instantiated fragment with embedded database definition\n");
+		console.log(`Found ${allFragnoDatabases.length} FragnoDatabase instance(s) across ${uniqueTargets.length} file(s)`);
+		const firstAdapter = allFragnoDatabases[0].adapter;
+		if (!allFragnoDatabases.every((db) => db.adapter === firstAdapter)) throw new Error("All fragments must use the same database adapter instance. Mixed adapters are not supported.");
+		console.log("\nMigrating all fragments to their latest versions...\n");
+		let results;
+		try {
+			results = await executeMigrations(allFragnoDatabases);
+		} catch (error) {
+			throw new Error(`Migration failed: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		for (const result of results) {
+			console.log(`Fragment: ${result.namespace}`);
+			console.log(`  Current version: ${result.fromVersion}`);
+			console.log(`  Target version: ${result.toVersion}`);
+			if (result.didMigrate) console.log(`  ✓ Migration completed: v${result.fromVersion} → v${result.toVersion}\n`);
+			else console.log(`  ✓ Already at latest version. No migration needed.\n`);
+		}
+		console.log("═══════════════════════════════════════");
+		console.log("Migration Summary");
+		console.log("═══════════════════════════════════════");
+		const migrated = results.filter((r) => r.didMigrate);
+		const skipped = results.filter((r) => !r.didMigrate);
+		if (migrated.length > 0) {
+			console.log(`\n✓ Migrated ${migrated.length} fragment(s):`);
+			for (const r of migrated) console.log(`  - ${r.namespace}: v${r.fromVersion} → v${r.toVersion}`);
+		}
+		if (skipped.length > 0) {
+			console.log(`\n○ Skipped ${skipped.length} fragment(s) (already up-to-date):`);
+			for (const r of skipped) console.log(`  - ${r.namespace}: v${r.toVersion}`);
+		}
+		console.log("\n✓ All migrations completed successfully");
+	}
+});
+
+//#endregion
+//#region src/commands/db/info.ts
+const infoCommand = define({
 	name: "info",
 	description: "Display database information and migration status",
-	args: { target: {
-		type: "positional",
-		description: "Path to the file that exports a FragnoDatabase instance"
-	} },
-	run: info
-};
+	args: {},
+	run: async (ctx) => {
+		const targets = ctx.positionals;
+		if (targets.length === 0) throw new Error("At least one target file path is required");
+		const uniqueTargets = Array.from(new Set(targets));
+		const allFragnoDatabases = [];
+		for (const target of uniqueTargets) {
+			const targetPath = resolve(process.cwd(), target);
+			console.log(`Loading target file: ${targetPath}`);
+			let targetModule;
+			try {
+				targetModule = await import(targetPath);
+			} catch (error) {
+				throw new Error(`Failed to import target file ${target}: ${error instanceof Error ? error.message : String(error)}`);
+			}
+			const fragnoDatabases = findFragnoDatabases(targetModule);
+			if (fragnoDatabases.length === 0) {
+				console.warn(`Warning: No FragnoDatabase instances found in ${target}.\nMake sure you export either:\n  - A FragnoDatabase instance created with .create(adapter)\n  - An instantiated fragment with embedded database definition\n`);
+				continue;
+			}
+			if (fragnoDatabases.length > 1) console.warn(`Warning: Multiple FragnoDatabase instances found in ${target} (${fragnoDatabases.length}). Showing info for all of them.`);
+			allFragnoDatabases.push(...fragnoDatabases);
+		}
+		if (allFragnoDatabases.length === 0) throw new Error("No FragnoDatabase instances found in any of the target files.\nMake sure your files export either:\n  - A FragnoDatabase instance created with .create(adapter)\n  - An instantiated fragment with embedded database definition\n");
+		const dbInfos = await Promise.all(allFragnoDatabases.map(async (fragnoDb) => {
+			const info = {
+				namespace: fragnoDb.namespace,
+				schemaVersion: fragnoDb.schema.version,
+				migrationSupport: !!fragnoDb.adapter.createMigrationEngine
+			};
+			if (fragnoDb.adapter.createMigrationEngine) try {
+				const currentVersion = await fragnoDb.adapter.createMigrationEngine(fragnoDb.schema, fragnoDb.namespace).getVersion();
+				info.currentVersion = currentVersion;
+				info.pendingVersions = fragnoDb.schema.version - currentVersion;
+				if (info.pendingVersions > 0) info.status = `Pending (${info.pendingVersions} migration(s))`;
+				else if (info.pendingVersions === 0) info.status = "Up to date";
+			} catch (error) {
+				info.error = error instanceof Error ? error.message : String(error);
+				info.status = "Error";
+			}
+			else info.status = "Schema only";
+			return info;
+		}));
+		const hasMigrationSupport = dbInfos.some((info) => info.migrationSupport);
+		console.log("");
+		console.log(`Found ${allFragnoDatabases.length} database(s) across ${uniqueTargets.length} file(s):`);
+		console.log("");
+		const namespaceHeader = "Namespace";
+		const versionHeader = "Schema";
+		const currentHeader = "Current";
+		const statusHeader = "Status";
+		const maxNamespaceLen = Math.max(9, ...dbInfos.map((info) => info.namespace.length));
+		const namespaceWidth = Math.max(maxNamespaceLen + 2, 20);
+		const versionWidth = 8;
+		const currentWidth = 9;
+		const statusWidth = 25;
+		console.log(namespaceHeader.padEnd(namespaceWidth) + versionHeader.padEnd(versionWidth) + (hasMigrationSupport ? currentHeader.padEnd(currentWidth) : "") + statusHeader);
+		console.log("-".repeat(namespaceWidth) + "-".repeat(versionWidth) + (hasMigrationSupport ? "-".repeat(currentWidth) : "") + "-".repeat(statusWidth));
+		for (const info of dbInfos) {
+			const currentVersionStr = info.currentVersion !== void 0 ? String(info.currentVersion) : "-";
+			console.log(info.namespace.padEnd(namespaceWidth) + String(info.schemaVersion).padEnd(versionWidth) + (hasMigrationSupport ? currentVersionStr.padEnd(currentWidth) : "") + (info.status || "-"));
+		}
+		console.log("");
+		if (!hasMigrationSupport) {
+			console.log("Note: These adapters do not support migrations.");
+			console.log("Use '@fragno-dev/cli db generate' to generate schema files.");
+		} else if (dbInfos.some((info) => info.pendingVersions && info.pendingVersions > 0)) console.log("Run '@fragno-dev/cli db migrate <target>' to apply pending migrations.");
+	}
+});
+
+//#endregion
+//#region src/cli.ts
 const dbSubCommands = /* @__PURE__ */ new Map();
 dbSubCommands.set("generate", generateCommand);
 dbSubCommands.set("migrate", migrateCommand);
@@ -301,14 +286,14 @@ function printDbHelp() {
 	console.log("");
 	console.log("Run '@fragno-dev/cli db <command> --help' for more information.");
 }
-const dbCommand = {
+const dbCommand = define({
 	name: "db",
 	description: "Database management commands",
 	run: printDbHelp
-};
+});
 const rootSubCommands = /* @__PURE__ */ new Map();
 rootSubCommands.set("db", dbCommand);
-const mainCommand = {
+const mainCommand = define({
 	name: "@fragno-dev/cli",
 	description: "Fragno CLI - Tools for working with Fragno fragments",
 	run: () => {
@@ -321,7 +306,7 @@ const mainCommand = {
 		console.log("");
 		console.log("Run '@fragno-dev/cli <command> --help' for more information.");
 	}
-};
+});
 if (import.meta.main) try {
 	const args = process.argv.slice(2);
 	if (args[0] === "db" && args.length > 1) {