@happyvertical/smrt-cli 0.40.9 → 0.40.11

package/AGENTS.md

@@ -8,7 +8,7 @@ Developer CLI with lazy-loaded commands, manifest discovery, and class introspec
 smrt introspect              # Discover SMRT objects in project
 smrt db:status               # Pending schema changes + failed migration classification
 smrt db:migrate              # Apply migrations
-smrt db:migrate --force-migration <exact-id> # Force one generated migration only
+smrt db:migrate --force-migration <exact-id> [--force-migration <exact-id>...] # Force exact generated migrations in one atomic batch
 smrt db:migrate-uuid         # Convert schema-declared UUID text columns after data remap
 smrt db:diff                 # Show schema differences without generating migration files
 smrt db:rollback             # Rollback migrations

package/README.md

@@ -26,7 +26,7 @@ pnpm add -D @happyvertical/smrt-cli
 |---------|------------|
 | `smrt db:status` | Show pending schema changes and classify failed migration history |
 | `smrt db:migrate` | Apply pending migrations |
-| `smrt db:migrate --force-migration <exact-id>` | Force one generated migration while preserving guards for every other migration in the batch |
+| `smrt db:migrate --force-migration <exact-id> [--force-migration <exact-id>...]` | Force one or more exact generated migrations in one atomic batch while preserving every other guard |
 | `smrt db:migrate-uuid` | Convert schema-declared UUID text columns to native PostgreSQL uuid after data has been remapped |
 | `smrt db:diff` | Show schema differences without generating migration files |
 | `smrt db:rollback` | Rollback last migration |
@@ -37,11 +37,23 @@ migrations are manifest-driven; model schema with SMRT objects and apply changes
 with `smrt db:migrate`.
 
 Use `--force-migration <exact-id>` for a known checksum, failed, or interrupted
-migration that is safe to retry. The selector is an exact generated migration
-ID, and unrelated checksum, failed, and running records remain fail-closed even
-when the atomic batch reconciles live schema drift. Global `--force` remains
-available for backward compatibility but intentionally overrides guards for the
-whole pending batch.
+migration that is safe to retry. Repeat the flag to recover multiple verified
+IDs in the same atomic invocation:
+
+```bash
+smrt db:migrate \
+  --force-migration create_table_commissions \
+  --force-migration create_table_referral_links
+```
+
+Each selector must be one exact generated migration ID. Comma-separated lists,
+wildcards, empty values, and combining exact selectors with global `--force`
+are rejected, as are IDs absent from the current generated migration batch.
+Duplicate exact IDs are normalized to one selection. Unrelated checksum,
+failed, and running records remain fail-closed even when the atomic batch
+reconciles live schema drift. Global `--force` remains available by itself for
+backward compatibility but intentionally overrides guards for the whole pending
+batch.
 
 ### Code Generation
 

package/dist/{commands-CFm89PR4.js → commands-mHvAZYmi.js}

@@ -6477,6 +6477,43 @@ function formatStiConflictIdentity(conflict) {
 	const entries = Object.entries(conflict.conflictIdentity);
 	return `${entries.length > 0 ? entries.map(([column, value]) => `${column}=${JSON.stringify(value)}`).join(", ") : "no non-_meta_type conflict columns"}${conflict.legacyId || conflict.qualifiedId ? ` (legacy id: ${conflict.legacyId ?? "unknown"}, qualified id: ${conflict.qualifiedId ?? "unknown"})` : ""}`;
 }
+/**
+* Normalize exact migration selectors from the public single/repeated CLI
+* forms. List and wildcard syntax are deliberately rejected: every selected
+* migration must be named by its own exact flag.
+*/
+function resolveForceMigrationSelection(force, value) {
+	const globalForce = Boolean(force);
+	if (value === void 0) return { force: globalForce };
+	const rawValues = Array.isArray(value) ? value : [value];
+	const forceMigrations = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const rawValue of rawValues) {
+		if (typeof rawValue !== "string") throw new Error("--force-migration requires an exact generated migration ID");
+		const migrationId = rawValue.trim();
+		if (migrationId.length === 0) throw new Error("--force-migration cannot be empty");
+		if (migrationId.includes(",")) throw new Error("Comma-separated --force-migration lists are not supported; repeat the flag for each exact ID");
+		if (/\s/u.test(migrationId)) throw new Error(`Invalid --force-migration ID "${migrationId}": exact IDs cannot contain whitespace`);
+		if (/[*?[\]{}]/u.test(migrationId)) throw new Error(`Invalid --force-migration ID "${migrationId}": wildcard selectors are not supported`);
+		if (migrationId.startsWith("-")) throw new Error(`Invalid --force-migration ID "${migrationId}": expected an exact generated migration ID`);
+		if (!seen.has(migrationId)) {
+			seen.add(migrationId);
+			forceMigrations.push(migrationId);
+		}
+	}
+	if (forceMigrations.length === 0) throw new Error("--force-migration requires at least one exact ID");
+	if (globalForce) throw new Error("Do not combine --force with --force-migration; choose global forcing or exact migration IDs");
+	return {
+		force: false,
+		forceMigrations
+	};
+}
+function assertForceMigrationTargetsExist(forceMigrations, generatedMigrationIds) {
+	if (!forceMigrations?.length) return;
+	const generated = new Set(generatedMigrationIds);
+	const unknown = forceMigrations.filter((migrationId) => !generated.has(migrationId));
+	if (unknown.length > 0) throw new Error(`--force-migration target${unknown.length === 1 ? "" : "s"} not found in the current generated migration batch: ${unknown.join(", ")}`);
+}
 function getErrorContext(error) {
 	if (error && typeof error === "object" && "context" in error) {
 		const context = error.context;
@@ -7044,7 +7081,8 @@ export default testManifest;
 			},
 			"force-migration": {
 				type: "string",
-				description: "Force only the generated migration with this exact ID; all other migration guards remain enabled"
+				description: "Force one generated migration by exact ID; repeat for multiple IDs while all other guards remain enabled",
+				multiple: true
 			},
 			"repair-data": {
 				type: "boolean",
@@ -7072,6 +7110,7 @@ export default testManifest;
 			console.log("\n🔄 Migrating database schema...\n");
 			let db;
 			try {
+				const forceSelection = resolveForceMigrationSelection(options.force, options["force-migration"]);
 				const { getPackageConfig } = await import("@happyvertical/smrt-config");
 				const { DEFAULT_CLI_CONFIG } = await import("./config-BwrFRL8L.js");
 				const config = getPackageConfig("cli", DEFAULT_CLI_CONFIG);
@@ -7189,6 +7228,10 @@ export default testManifest;
 				const partitionedChanges = partitionSchemaChanges(diff.changes, getClassForTable);
 				migrations.push(...partitionedChanges.migrations);
 				manualInterventions.push(...partitionedChanges.manualInterventions);
+				assertForceMigrationTargetsExist(forceSelection.forceMigrations, [...diff.added_tables.map((schema) => `create_table_${schema.tableName}`), ...migrations.flatMap((migration) => {
+					const migrationName = getSyntheticMigrationNameForAction(migration);
+					return migrationName ? [migrationName] : [];
+				})]);
 				console.log();
 				if (manualInterventions.length > 0) {
 					console.log("⚠️  Schema drift detected that requires manual intervention:\n");
@@ -7309,8 +7352,8 @@ export default testManifest;
 						const results = await tracker.applyAll(migrationDefs, {
 							atomic: true,
 							postgresSafe: false,
-							force: options.force ?? false,
-							forceMigrations: options["force-migration"] ? [options["force-migration"]] : void 0,
+							force: forceSelection.force,
+							forceMigrations: forceSelection.forceMigrations,
 							reconcile: true,
 							onProgress: (result) => {
 								if (!result.success) return;

package/dist/index.js

@@ -48,60 +48,94 @@ var _docsCommands = null;
 var _playgroundCommands = null;
 async function getGnodeCommands() {
 	if (!_gnodeCommands) {
-		const { gnodeCommands } = await import("./commands-CFm89PR4.js");
+		const { gnodeCommands } = await import("./commands-mHvAZYmi.js");
 		_gnodeCommands = gnodeCommands;
 	}
 	return _gnodeCommands;
 }
 async function getGitCommands() {
 	if (!_gitCommands) {
-		const { gitCommands } = await import("./commands-CFm89PR4.js");
+		const { gitCommands } = await import("./commands-mHvAZYmi.js");
 		_gitCommands = gitCommands;
 	}
 	return _gitCommands;
 }
 async function getGenerateCommands() {
 	if (!_generateCommands) {
-		const { generateCommands } = await import("./commands-CFm89PR4.js");
+		const { generateCommands } = await import("./commands-mHvAZYmi.js");
 		_generateCommands = generateCommands;
 	}
 	return _generateCommands;
 }
 async function getInitCommands() {
 	if (!_initCommands) {
-		const { initCommands } = await import("./commands-CFm89PR4.js");
+		const { initCommands } = await import("./commands-mHvAZYmi.js");
 		_initCommands = initCommands;
 	}
 	return _initCommands;
 }
 async function getUtilityCommands() {
 	if (!_utilityCommands) {
-		const { utilityCommands } = await import("./commands-CFm89PR4.js");
+		const { utilityCommands } = await import("./commands-mHvAZYmi.js");
 		_utilityCommands = utilityCommands;
 	}
 	return _utilityCommands;
 }
 async function getDispatchCommands() {
 	if (!_dispatchCommands) {
-		const { dispatchCommands } = await import("./commands-CFm89PR4.js");
+		const { dispatchCommands } = await import("./commands-mHvAZYmi.js");
 		_dispatchCommands = dispatchCommands;
 	}
 	return _dispatchCommands;
 }
 async function getDocsCommands() {
 	if (!_docsCommands) {
-		const { docsCommands } = await import("./commands-CFm89PR4.js");
+		const { docsCommands } = await import("./commands-mHvAZYmi.js");
 		_docsCommands = docsCommands;
 	}
 	return _docsCommands;
 }
 async function getPlaygroundCommands() {
 	if (!_playgroundCommands) {
-		const { playgroundCommands } = await import("./commands-CFm89PR4.js");
+		const { playgroundCommands } = await import("./commands-mHvAZYmi.js");
 		_playgroundCommands = playgroundCommands;
 	}
 	return _playgroundCommands;
 }
+function collectRepeatableOptionValues(argv, optionName) {
+	const flag = `--${optionName}`;
+	const inlinePrefix = `${flag}=`;
+	const values = [];
+	for (let index = 0; index < argv.length; index += 1) {
+		const token = argv[index];
+		if (token === "--") break;
+		if (token.startsWith(inlinePrefix)) {
+			values.push(token.slice(inlinePrefix.length));
+			continue;
+		}
+		if (token !== flag) continue;
+		const value = argv[index + 1];
+		if (value === void 0 || value.startsWith("-")) throw new Error(`Option ${flag} requires a value`);
+		values.push(value);
+		index += 1;
+	}
+	return values;
+}
+/**
+* Parse one command while preserving every occurrence of options marked
+* `multiple`. Non-repeatable options retain the shared SDK parser behavior.
+*/
+function parseCliCommandArgs(argv, commands, builtInCommands = {}) {
+	const parsed = parseCliArgs(argv, commands, builtInCommands);
+	const command = parsed.command ? builtInCommands[parsed.command] ?? commands.find((candidate) => candidate.name === parsed.command || candidate.aliases?.includes(parsed.command)) : void 0;
+	if (!command?.options) return parsed;
+	for (const [name, option] of Object.entries(command.options)) {
+		if (!option.multiple) continue;
+		const values = collectRepeatableOptionValues(argv, name);
+		if (values.length > 0) parsed.options[name] = values;
+	}
+	return parsed;
+}
 /**
 * Generate CLI commands for smrt objects
 */
@@ -263,7 +297,7 @@ var CLIGenerator = class {
 		return async (argv) => {
 			const commands = await this.generateCommands();
 			const processedArgv = this.preprocessObjectCommands(argv, commands);
-			const parsed = parseCliArgs(processedArgv, commands, {});
+			const parsed = parseCliCommandArgs(processedArgv, commands, {});
 			await this.executeCommand(parsed, commands, processedArgv);
 		};
 	}
@@ -672,7 +706,7 @@ var CLIGenerator = class {
 				this.exitWithError(`Command '${parsed.command}' has no handler defined`);
 				return;
 			}
-			const reParsed = parseCliArgs(processedArgv, [builtInCommand], {});
+			const reParsed = parseCliCommandArgs(processedArgv, [builtInCommand], {});
 			try {
 				await builtInCommand.handler(reParsed.args, reParsed.options);
 				return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@happyvertical/smrt-cli",
-  "version": "0.40.9",
+  "version": "0.40.11",
   "description": "Developer CLI for SMRT framework - introspection, testing, and project management",
   "type": "module",
   "main": "./dist/index.js",
@@ -32,12 +32,12 @@
     "acorn": "^8.17.0",
     "fast-glob": "3.3.3",
     "tar": "^7.5.19",
-    "@happyvertical/smrt-agents": "0.40.9",
-    "@happyvertical/smrt-config": "0.40.9",
-    "@happyvertical/smrt-dev-mcp": "0.40.9",
-    "@happyvertical/smrt-core": "0.40.9",
-    "@happyvertical/smrt-playground": "0.40.9",
-    "@happyvertical/smrt-types": "0.40.9"
+    "@happyvertical/smrt-config": "0.40.11",
+    "@happyvertical/smrt-dev-mcp": "0.40.11",
+    "@happyvertical/smrt-types": "0.40.11",
+    "@happyvertical/smrt-playground": "0.40.11",
+    "@happyvertical/smrt-agents": "0.40.11",
+    "@happyvertical/smrt-core": "0.40.11"
   },
   "devDependencies": {
     "@types/node": "24.13.2",
@@ -72,7 +72,7 @@
     "clean": "rm -rf dist",
     "dev": "npm run build:watch",
     "test": "vitest run",
-    "test:postgres": "node ../../scripts/run-with-ci-postgres.mjs -- pnpm exec vitest run src/commands/__tests__/db-migrate-uuid.test.ts",
+    "test:postgres": "node ../../scripts/run-with-ci-postgres.mjs -- pnpm exec vitest run src/commands/__tests__/db-migrate-uuid.test.ts src/commands/__tests__/db-migrate-force-postgres.test.ts",
     "test:watch": "vitest",
     "typecheck": "tsc -p tsconfig.typecheck.json",
     "cli": "tsx src/index.ts"