@teardown/cli 2.0.57 → 2.0.58

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@teardown/cli",
-	"version": "2.0.57",
+	"version": "2.0.58",
 	"private": false,
 	"type": "module",
 	"main": "./src/index.ts",
@@ -71,7 +71,7 @@
 	},
 	"devDependencies": {
 		"@biomejs/biome": "2.3.11",
-		"@teardown/tsconfig": "2.0.57",
+		"@teardown/tsconfig": "2.0.58",
 		"@types/bun": "1.3.5",
 		"@types/ejs": "^3.1.5",
 		"typescript": "5.9.3"

package/src/cli/commands/upgrade.ts

@@ -0,0 +1,264 @@
+import { spawn } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import chalk from "chalk";
+import { Command } from "commander";
+import ora from "ora";
+import { findConfigFile } from "../../config";
+import { TemplateGenerator } from "../../templates";
+
+/**
+ * Teardown packages that should be upgraded
+ */
+const TEARDOWN_PACKAGES = [
+	"@teardown/cli",
+	"@teardown/dev-client",
+	"@teardown/navigation",
+	"@teardown/metro-config",
+	"@teardown/navigation-metro",
+];
+
+/**
+ * Config files that can be upgraded from templates
+ */
+const UPGRADABLE_CONFIG_FILES = ["metro.config.js", "babel.config.js", "react-native.config.js", "Gemfile"];
+
+interface PackageJson {
+	name?: string;
+	version?: string;
+	dependencies?: Record<string, string>;
+	devDependencies?: Record<string, string>;
+}
+
+/**
+ * Fetch the latest version of a package from npm
+ */
+async function fetchLatestVersion(packageName: string): Promise<string | null> {
+	return new Promise((resolve) => {
+		const child = spawn("npm", ["view", packageName, "version"], {
+			stdio: ["ignore", "pipe", "pipe"],
+		});
+
+		let stdout = "";
+		child.stdout?.on("data", (data) => {
+			stdout += data.toString();
+		});
+
+		child.on("close", (code) => {
+			if (code === 0) {
+				resolve(stdout.trim());
+			} else {
+				resolve(null);
+			}
+		});
+
+		child.on("error", () => {
+			resolve(null);
+		});
+	});
+}
+
+/**
+ * Get the CLI package version
+ */
+function getCliVersion(): string {
+	try {
+		const __filename = fileURLToPath(import.meta.url);
+		const __dirname = path.dirname(__filename);
+		const packageJsonPath = path.resolve(__dirname, "../../../package.json");
+		const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+		return packageJson.version;
+	} catch {
+		return "0.0.1";
+	}
+}
+
+/**
+ * Create the upgrade command
+ */
+export function createUpgradeCommand(): Command {
+	const command = new Command("upgrade")
+		.description("Upgrade Teardown packages and config files to the latest versions")
+		.option("-f, --force", "Force upgrade config files even if they exist", false)
+		.option("--skip-install", "Skip running bun install after upgrade", false)
+		.option("--skip-config", "Skip upgrading config files", false)
+		.option("--dry-run", "Show what would be upgraded without making changes", false)
+		.action(async (options) => {
+			const projectRoot = process.cwd();
+
+			// Check if this is a Teardown project
+			const configPath = findConfigFile(projectRoot);
+			if (!configPath) {
+				console.error(chalk.red("Error: This does not appear to be a Teardown project."));
+				console.log(chalk.gray("\nNo teardown.config.ts found."));
+				console.log(chalk.gray("Run 'teardown init <name>' to initialize a new project."));
+				process.exit(1);
+			}
+
+			console.log(chalk.cyan("\nTeardown Upgrade\n"));
+
+			// Check for package.json
+			const packageJsonPath = path.join(projectRoot, "package.json");
+			if (!fs.existsSync(packageJsonPath)) {
+				console.error(chalk.red("Error: No package.json found in project root."));
+				process.exit(1);
+			}
+
+			const packageJson: PackageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+			const updates: { name: string; from: string; to: string }[] = [];
+
+			// Fetch latest versions and check for updates
+			const versionSpinner = ora("Checking for package updates...").start();
+
+			for (const pkg of TEARDOWN_PACKAGES) {
+				// Check if package is in dependencies or devDependencies
+				const currentVersion = packageJson.dependencies?.[pkg] || packageJson.devDependencies?.[pkg];
+
+				if (!currentVersion) {
+					continue;
+				}
+
+				const latestVersion = await fetchLatestVersion(pkg);
+				if (latestVersion) {
+					const cleanCurrentVersion = currentVersion.replace(/^\^|~/, "");
+					if (cleanCurrentVersion !== latestVersion) {
+						updates.push({
+							name: pkg,
+							from: currentVersion,
+							to: `^${latestVersion}`,
+						});
+					}
+				}
+			}
+
+			versionSpinner.succeed("Checked package versions");
+
+			// Display updates
+			if (updates.length > 0) {
+				console.log(chalk.yellow("\nPackages to update:"));
+				for (const update of updates) {
+					console.log(
+						chalk.gray(`  ${update.name}: `) + chalk.red(update.from) + chalk.gray(" -> ") + chalk.green(update.to)
+					);
+				}
+			} else {
+				console.log(chalk.green("\nAll Teardown packages are up to date!"));
+			}
+
+			// Apply updates if not dry run
+			if (!options.dryRun && updates.length > 0) {
+				const updateSpinner = ora("Updating package.json...").start();
+
+				for (const update of updates) {
+					if (packageJson.dependencies?.[update.name]) {
+						packageJson.dependencies[update.name] = update.to;
+					}
+					if (packageJson.devDependencies?.[update.name]) {
+						packageJson.devDependencies[update.name] = update.to;
+					}
+				}
+
+				fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, "\t") + "\n", "utf-8");
+				updateSpinner.succeed("Updated package.json");
+			}
+
+			// Upgrade config files
+			if (!options.skipConfig) {
+				console.log(chalk.yellow("\nConfig files:"));
+
+				// Read current config to get variables
+				const config = await import(configPath);
+				const configData = config.default || config;
+
+				const slug = configData.slug || configData.name?.toLowerCase().replace(/[^a-z0-9]+/g, "-") || "app";
+				const appName = configData.name || "App";
+				const bundleIdentifier = configData.ios?.bundleIdentifier || `com.example.${slug.replace(/-/g, "")}`;
+				const packageName = configData.android?.packageName || bundleIdentifier;
+
+				const generator = new TemplateGenerator({
+					projectRoot,
+					variables: {
+						slug,
+						appName,
+						bundleIdentifier,
+						version: configData.version || "1.0.0",
+						buildNumber: configData.ios?.buildNumber || 1,
+						packageName,
+						versionCode: configData.android?.versionCode || 1,
+						versionName: configData.version || "1.0.0",
+						cliVersion: `^${getCliVersion()}`,
+					},
+					force: options.force,
+					dryRun: options.dryRun,
+				});
+
+				const configFilesUpdated: string[] = [];
+				const configFilesSkipped: string[] = [];
+
+				for (const file of UPGRADABLE_CONFIG_FILES) {
+					const filePath = path.join(projectRoot, file);
+					const exists = fs.existsSync(filePath);
+
+					if (exists && !options.force) {
+						configFilesSkipped.push(file);
+						console.log(chalk.gray(`  ${file}: skipped (use --force to overwrite)`));
+					} else {
+						if (!options.dryRun) {
+							const result = await generator.generateRootConfigFiles();
+							if (result.filesCreated.some((f) => f.endsWith(file))) {
+								configFilesUpdated.push(file);
+								console.log(chalk.green(`  ${file}: updated`));
+							}
+						} else {
+							console.log(chalk.cyan(`  ${file}: would be updated`));
+						}
+					}
+				}
+			}
+
+			// Run bun install
+			if (!options.skipInstall && !options.dryRun && updates.length > 0) {
+				const installSpinner = ora("Installing updated dependencies...").start();
+				await new Promise<void>((resolve, reject) => {
+					const child = spawn("bun", ["install"], {
+						cwd: projectRoot,
+						stdio: ["ignore", "pipe", "pipe"],
+					});
+
+					let stderr = "";
+					child.stderr?.on("data", (data) => {
+						stderr += data.toString();
+					});
+
+					child.on("close", (code) => {
+						if (code === 0) {
+							installSpinner.succeed("Dependencies installed");
+							resolve();
+						} else {
+							installSpinner.fail("Failed to install dependencies");
+							console.error(chalk.red(stderr));
+							reject(new Error(`bun install exited with code ${code}`));
+						}
+					});
+
+					child.on("error", (err) => {
+						installSpinner.fail("Failed to run bun install");
+						reject(err);
+					});
+				});
+			}
+
+			// Summary
+			if (options.dryRun) {
+				console.log(chalk.cyan("\n[Dry run] No changes were made."));
+			} else if (updates.length > 0) {
+				console.log(chalk.green("\nUpgrade complete!"));
+				console.log(chalk.gray("\nNext steps:"));
+				console.log(chalk.cyan("  1. teardown prebuild --clean") + chalk.gray(" - Regenerate native projects"));
+				console.log(chalk.cyan("  2. teardown run ios") + chalk.gray(" or ") + chalk.cyan("teardown run android"));
+			}
+		});
+
+	return command;
+}

package/src/cli/index.ts

@@ -8,6 +8,7 @@ import { createInitCommand } from "./commands/init";
 import { createPluginsCommand } from "./commands/plugins";
 import { createPrebuildCommand } from "./commands/prebuild";
 import { createRunCommand } from "./commands/run";
+import { createUpgradeCommand } from "./commands/upgrade";
 import { createValidateCommand } from "./commands/validate";
 
 /**
@@ -28,6 +29,7 @@ export function createProgram(): Command {
 	program.addCommand(createPrebuildCommand());
 	program.addCommand(createValidateCommand());
 	program.addCommand(createInitCommand());
+	program.addCommand(createUpgradeCommand());
 	program.addCommand(createPluginsCommand());
 	program.addCommand(createRunCommand());
 	program.addCommand(createDevCommand());
@@ -56,4 +58,5 @@ export { createPluginsCommand } from "./commands/plugins";
 // Export commands for testing
 export { createPrebuildCommand } from "./commands/prebuild";
 export { createRunCommand } from "./commands/run";
+export { createUpgradeCommand } from "./commands/upgrade";
 export { createValidateCommand } from "./commands/validate";