@teardown/cli 1.2.39 → 2.0.41

package/src/transformers/android/gradle.ts

@@ -0,0 +1,400 @@
+import type { ProcessedAppConfig } from "../../config/types";
+import type { PluginContext } from "../../plugins/context";
+
+/**
+ * Gradle transformer for Android build.gradle.kts files
+ *
+ * Uses regex-based string manipulation since Gradle DSL is complex
+ * and AST parsing from JavaScript is unreliable.
+ */
+export class GradleTransformer {
+	/**
+	 * Transform the build.gradle files with configuration
+	 */
+	async transform(context: PluginContext, config: ProcessedAppConfig): Promise<void> {
+		const { log } = context;
+
+		log.debug("Transforming build.gradle files...");
+
+		// Transform app/build.gradle.kts
+		await this.transformAppBuildGradle(context, config);
+
+		// Transform root build.gradle.kts if needed
+		await this.transformRootBuildGradle(context, config);
+
+		log.debug("Gradle transformation complete");
+	}
+
+	/**
+	 * Transform app/build.gradle.kts
+	 */
+	private async transformAppBuildGradle(context: PluginContext, config: ProcessedAppConfig): Promise<void> {
+		const { fs, log, androidPaths } = context;
+
+		let content: string;
+
+		try {
+			content = await fs.readFile(androidPaths.appBuildGradle);
+		} catch {
+			log.warn("app/build.gradle.kts not found, creating default");
+			content = this.createDefaultAppBuildGradle(config);
+		}
+
+		// Apply transformations
+		content = this.applyNamespace(content, config);
+		content = this.applyVersionCode(content, config);
+		content = this.applyVersionName(content, config);
+		content = this.applySdkVersions(content, config);
+		content = this.applyDependencies(content, config);
+
+		await fs.writeFile(androidPaths.appBuildGradle, content);
+	}
+
+	/**
+	 * Transform root build.gradle.kts
+	 */
+	private async transformRootBuildGradle(context: PluginContext, _config: ProcessedAppConfig): Promise<void> {
+		const { fs, androidPaths } = context;
+
+		let content: string;
+
+		try {
+			content = await fs.readFile(androidPaths.buildGradle);
+		} catch {
+			// Root build.gradle is optional
+			return;
+		}
+
+		// Apply any root-level transformations if needed
+		// (e.g., adding classpath dependencies for plugins)
+
+		await fs.writeFile(androidPaths.buildGradle, content);
+	}
+
+	/**
+	 * Create default app/build.gradle.kts
+	 */
+	private createDefaultAppBuildGradle(config: ProcessedAppConfig): string {
+		const packageName = config.android?.packageName ?? "com.example.app";
+		const minSdk = config.android?.minSdkVersion ?? 23;
+		const targetSdk = config.android?.targetSdkVersion ?? 34;
+		const compileSdk = config.android?.compileSdkVersion ?? 34;
+		const versionCode = config.android?.versionCode ?? 1;
+		const versionName = config.version;
+
+		return `plugins {
+    alias(libs.plugins.android.application)
+    alias(libs.plugins.kotlin.android)
+}
+
+android {
+    namespace = "${packageName}"
+    compileSdk = ${compileSdk}
+
+    defaultConfig {
+        applicationId = "${packageName}"
+        minSdk = ${minSdk}
+        targetSdk = ${targetSdk}
+        versionCode = ${versionCode}
+        versionName = "${versionName}"
+    }
+
+    buildTypes {
+        release {
+            isMinifyEnabled = false
+            proguardFiles(
+                getDefaultProguardFile("proguard-android-optimize.txt"),
+                "proguard-rules.pro"
+            )
+        }
+    }
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_17
+    }
+
+    kotlinOptions {
+        jvmTarget = "17"
+    }
+}
+
+dependencies {
+    implementation(libs.react.native)
+}
+`;
+	}
+
+	/**
+	 * Apply namespace (package name)
+	 */
+	private applyNamespace(content: string, config: ProcessedAppConfig): string {
+		if (!config.android?.packageName) {
+			return content;
+		}
+
+		let result = content;
+
+		// Update namespace
+		result = result.replace(/namespace\s*=\s*"[^"]*"/, `namespace = "${config.android.packageName}"`);
+
+		// Update applicationId
+		result = result.replace(/applicationId\s*=\s*"[^"]*"/, `applicationId = "${config.android.packageName}"`);
+
+		return result;
+	}
+
+	/**
+	 * Apply version code
+	 */
+	private applyVersionCode(content: string, config: ProcessedAppConfig): string {
+		const versionCode = config.android?.versionCode ?? 1;
+
+		return content.replace(/versionCode\s*=\s*\d+/, `versionCode = ${versionCode}`);
+	}
+
+	/**
+	 * Apply version name
+	 */
+	private applyVersionName(content: string, config: ProcessedAppConfig): string {
+		return content.replace(/versionName\s*=\s*"[^"]*"/, `versionName = "${config.version}"`);
+	}
+
+	/**
+	 * Apply SDK versions
+	 */
+	private applySdkVersions(content: string, config: ProcessedAppConfig): string {
+		let result = content;
+
+		if (config.android?.compileSdkVersion) {
+			result = result.replace(/compileSdk\s*=\s*\d+/, `compileSdk = ${config.android.compileSdkVersion}`);
+		}
+
+		if (config.android?.minSdkVersion) {
+			result = result.replace(/minSdk\s*=\s*\d+/, `minSdk = ${config.android.minSdkVersion}`);
+		}
+
+		if (config.android?.targetSdkVersion) {
+			result = result.replace(/targetSdk\s*=\s*\d+/, `targetSdk = ${config.android.targetSdkVersion}`);
+		}
+
+		return result;
+	}
+
+	/**
+	 * Apply dependencies
+	 */
+	private applyDependencies(content: string, config: ProcessedAppConfig): string {
+		if (config.resolvedGradleDependencies.length === 0) {
+			return content;
+		}
+
+		// Find the dependencies block
+		const dependenciesMatch = content.match(/dependencies\s*\{([^}]*)\}/s);
+
+		if (!dependenciesMatch) {
+			// Add dependencies block if it doesn't exist
+			const depsContent = config.resolvedGradleDependencies.map((dep) => `    implementation("${dep}")`).join("\n");
+
+			return `${content}\ndependencies {\n${depsContent}\n}\n`;
+		}
+
+		// Check which dependencies need to be added
+		const existingDeps = dependenciesMatch[1];
+		const depsToAdd: string[] = [];
+
+		for (const dep of config.resolvedGradleDependencies) {
+			// Extract artifact ID for comparison
+			const artifactMatch = dep.match(/:([^:]+):/);
+			const artifactId = artifactMatch ? artifactMatch[1] : dep;
+
+			if (!existingDeps.includes(artifactId)) {
+				depsToAdd.push(dep);
+			}
+		}
+
+		if (depsToAdd.length === 0) {
+			return content;
+		}
+
+		// Insert new dependencies
+		const newDeps = depsToAdd.map((dep) => `    implementation("${dep}")`).join("\n");
+
+		return content.replace(/dependencies\s*\{/, `dependencies {\n${newDeps}`);
+	}
+
+	/**
+	 * Add a dependency to build.gradle content
+	 */
+	static addDependency(content: string, dependency: string, type = "implementation"): string {
+		// Check if dependency already exists
+		const artifactMatch = dependency.match(/:([^:]+):/);
+		const artifactId = artifactMatch ? artifactMatch[1] : dependency;
+
+		if (content.includes(artifactId)) {
+			return content;
+		}
+
+		// Add to dependencies block
+		return content.replace(/dependencies\s*\{/, `dependencies {\n    ${type}("${dependency}")`);
+	}
+
+	/**
+	 * Add a plugin to build.gradle content
+	 */
+	static addPlugin(content: string, plugin: string): string {
+		// Check if plugin already exists
+		if (content.includes(plugin)) {
+			return content;
+		}
+
+		// Add to plugins block
+		return content.replace(/plugins\s*\{/, `plugins {\n    id("${plugin}")`);
+	}
+
+	/**
+	 * Set a property in build.gradle content
+	 */
+	static setProperty(content: string, property: string, value: string | number | boolean): string {
+		const valueStr = typeof value === "string" ? `"${value}"` : String(value);
+		const regex = new RegExp(`${property}\\s*=\\s*[^\\n]+`);
+
+		if (content.match(regex)) {
+			return content.replace(regex, `${property} = ${valueStr}`);
+		}
+
+		// Property doesn't exist, would need context to know where to add it
+		return content;
+	}
+
+	/**
+	 * Add manifest placeholder
+	 */
+	static addManifestPlaceholder(content: string, key: string, value: string): string {
+		// Check if manifestPlaceholders block exists
+		if (content.includes("manifestPlaceholders")) {
+			// Add to existing block
+			return content.replace(
+				/manifestPlaceholders\s*\+?=\s*mapOf\(/,
+				`manifestPlaceholders += mapOf(\n            "${key}" to "${value}",`
+			);
+		}
+
+		// Add manifestPlaceholders to defaultConfig
+		return content.replace(
+			/defaultConfig\s*\{/,
+			`defaultConfig {\n        manifestPlaceholders += mapOf("${key}" to "${value}")`
+		);
+	}
+
+	/**
+	 * Add signing config
+	 */
+	static addSigningConfig(
+		content: string,
+		name: string,
+		config: {
+			storeFile: string;
+			storePassword?: string;
+			keyAlias: string;
+			keyPassword?: string;
+		}
+	): string {
+		const signingBlock = `
+    signingConfigs {
+        create("${name}") {
+            storeFile = file("${config.storeFile}")
+            storePassword = ${config.storePassword ? `"${config.storePassword}"` : 'System.getenv("KEYSTORE_PASSWORD")'}
+            keyAlias = "${config.keyAlias}"
+            keyPassword = ${config.keyPassword ? `"${config.keyPassword}"` : 'System.getenv("KEY_PASSWORD")'}
+        }
+    }
+`;
+
+		// Add before buildTypes
+		return content.replace(/buildTypes\s*\{/, `${signingBlock}\n    buildTypes {`);
+	}
+
+	/**
+	 * Enable build feature
+	 */
+	static enableBuildFeature(content: string, feature: string): string {
+		// Check if buildFeatures block exists
+		if (content.includes("buildFeatures")) {
+			return content.replace(/buildFeatures\s*\{/, `buildFeatures {\n        ${feature} = true`);
+		}
+
+		// Add buildFeatures block after android {
+		return content.replace(/android\s*\{/, `android {\n    buildFeatures {\n        ${feature} = true\n    }`);
+	}
+}
+
+/**
+ * Strings.xml transformer for Android
+ */
+export class StringsTransformer {
+	/**
+	 * Transform strings.xml with configuration
+	 */
+	async transform(context: PluginContext, config: ProcessedAppConfig): Promise<void> {
+		const { fs, log, androidPaths } = context;
+
+		log.debug("Transforming strings.xml...");
+
+		let content: string;
+
+		try {
+			content = await fs.readFile(androidPaths.stringsXml);
+		} catch {
+			content = this.createDefaultStringsXml(config);
+		}
+
+		// Update app_name
+		content = content.replace(
+			/<string name="app_name">[^<]*<\/string>/,
+			`<string name="app_name">${this.escapeXml(config.name)}</string>`
+		);
+
+		await fs.writeFile(androidPaths.stringsXml, content);
+
+		log.debug("strings.xml transformation complete");
+	}
+
+	/**
+	 * Create default strings.xml
+	 */
+	private createDefaultStringsXml(config: ProcessedAppConfig): string {
+		return `<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="app_name">${this.escapeXml(config.name)}</string>
+</resources>`;
+	}
+
+	/**
+	 * Escape XML special characters
+	 */
+	private escapeXml(text: string): string {
+		return text
+			.replace(/&/g, "&amp;")
+			.replace(/</g, "&lt;")
+			.replace(/>/g, "&gt;")
+			.replace(/"/g, "&quot;")
+			.replace(/'/g, "&apos;");
+	}
+
+	/**
+	 * Add a string resource
+	 */
+	static addString(content: string, name: string, value: string): string {
+		// Check if string already exists
+		if (content.includes(`name="${name}"`)) {
+			return content.replace(
+				new RegExp(`<string name="${name}">[^<]*</string>`),
+				`<string name="${name}">${value}</string>`
+			);
+		}
+
+		// Add new string before </resources>
+		return content.replace("</resources>", `    <string name="${name}">${value}</string>\n</resources>`);
+	}
+}

package/src/transformers/android/index.ts

@@ -0,0 +1,19 @@
+/**
+ * Android file transformers for Teardown Launchpad
+ */
+
+export { GradleTransformer, StringsTransformer } from "./gradle";
+export type {
+	AndroidActivityXml,
+	AndroidApplication,
+	AndroidFeature,
+	AndroidIntentFilterXml,
+	AndroidManifestXml,
+	AndroidMetaData,
+	AndroidPermission,
+	AndroidProviderXml,
+	AndroidQueries,
+	AndroidReceiverXml,
+	AndroidServiceXml,
+} from "./manifest";
+export { AndroidManifestTransformer } from "./manifest";