create-droid 1.0.0

package/README.md

@@ -0,0 +1,83 @@
+# create-droid 🤖
+
+The fastest way to start an Android project. No Studio required.
+
+[![npm version](https://img.shields.io/npm/v/create-droid.svg)](https://www.npmjs.com/package/create-droid)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Why?
+
+Most Android tutorials assume you want to download a 2GB IDE just to write "Hello World".
+Modern web developers are used to tools like `create-react-app` or `vite` – simple, fast, and CLI-first.
+
+**`create-droid` brings that DX to Android.**
+
+*   **⚡️ Fast:** Scaffolds a project in seconds.
+*   **🚫 No Studio Required:** Fully functional Gradle builds out of the box.
+*   **🛠 Local SDK Management:** Auto-downloads and configures the Android SDK locally (no global pollution).
+*   **💎 Modern Stack:** Kotlin DSL, Version Catalogs (`libs.versions.toml`), Jetpack Compose, and Material 3 by default.
+*   **🐧 Linux & Mac First:** Designed for terminal-centric workflows.
+
+## Prerequisites
+
+*   **Node.js**: >= 18.0.0
+*   **Java (JDK)**: >= 17 (Run `java -version` to check)
+
+## Usage
+
+Simply run:
+
+```bash
+npm create droid my-app
+# or
+npx create-droid my-app
+```
+
+Follow the interactive prompts:
+1.  **Project Name**: Defaults to directory name.
+2.  **UI Framework**: Choose **Jetpack Compose** (Modern declarative UI) or **XML Views** (Classic).
+
+### After Scaffolding
+
+```bash
+cd my-app
+
+# Build and verify the project
+./gradlew build
+
+# Install on a connected device/emulator
+./gradlew installDebug
+```
+
+## What's Inside?
+
+The generated project is **clean** and follows modern best practices:
+
+```text
+my-app/
+├── app/
+│   ├── src/main/java/com/example/  # Your Kotlin source code
+│   └── build.gradle.kts            # App module configuration
+├── gradle/
+│   └── libs.versions.toml          # Central dependency management
+├── build.gradle.kts                # Root project configuration
+├── settings.gradle.kts             # Module inclusion
+├── gradlew                         # The Gradle wrapper (runs builds)
+└── local.properties                # SDK location (auto-generated)
+```
+
+## Advanced
+
+### Customizing the SDK Location
+
+By default, the SDK is installed to `~/.local/share/create-android-app/sdk`.
+If you already have an SDK installed, simply set the environment variable:
+
+```bash
+export ANDROID_HOME=/path/to/existing/sdk
+npm create droid my-app
+```
+
+## License
+
+MIT © YELrhilassi

package/bin/cli.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { run } from "../dist/index.js";
+
+run(process.argv.slice(2)).catch(err => {
+  console.error(err);
+  process.exit(1);
+});

package/dist/env/checkEnv.js

@@ -0,0 +1,42 @@
+import { execa } from 'execa';
+import { CONSTANTS } from '../utils/constants.js';
+import { logger } from '../utils/logger.js';
+export async function checkEnv() {
+    // 1. Check Node
+    const nodeVersion = process.version;
+    if (!nodeVersion.startsWith('v' + CONSTANTS.NODE_VERSION_REQ) && parseInt(nodeVersion.substring(1)) < CONSTANTS.NODE_VERSION_REQ) {
+        logger.error(`Node.js ${CONSTANTS.NODE_VERSION_REQ}+ required. Found ${nodeVersion}`);
+        process.exit(1);
+    }
+    logger.success(`Node.js ${nodeVersion}`);
+    // 2. Check Java (Robust Regex)
+    try {
+        const { stdout, stderr } = await execa('java', ['-version']);
+        const output = stdout || stderr; // Java version often prints to stderr
+        // Regex to capture major version: "version \"17.0.1\"" or "17.0.1"
+        const versionMatch = output.match(/version\s+"?(\d+)/i);
+        if (versionMatch && versionMatch[1]) {
+            const majorVersion = parseInt(versionMatch[1], 10);
+            if (majorVersion >= CONSTANTS.JAVA_VERSION_REQ) {
+                logger.success(`Java version ${majorVersion} detected.`);
+                return;
+            }
+            else {
+                logger.error(`Java ${CONSTANTS.JAVA_VERSION_REQ}+ required. Found version ${majorVersion}.`);
+            }
+        }
+        else {
+            logger.warn(`Could not parse Java version from output: ${output}`);
+            logger.warn(`Assuming compatible if "17" or "21" is present...`);
+            if (!output.includes('17') && !output.includes('21')) {
+                logger.error(`Java 17+ required. Please verify your installation.`);
+                process.exit(1);
+            }
+        }
+    }
+    catch (e) {
+        logger.error(`Java runtime not found. Please install JDK 17+.`);
+        logger.info(`Download: https://adoptium.net/temurin/releases/`);
+        process.exit(1);
+    }
+}

package/dist/gradle/setupGradle.js

@@ -0,0 +1,232 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { execa } from 'execa';
+import { logger } from '../utils/logger.js';
+import { pipeline } from 'stream/promises';
+import { createWriteStream } from 'fs';
+export async function setupGradle(projectPath) {
+    const wrapperDir = path.join(projectPath, 'gradle', 'wrapper');
+    await fs.ensureDir(wrapperDir);
+    const wrapperJarPath = path.join(wrapperDir, 'gradle-wrapper.jar');
+    const gradlewPath = path.join(projectPath, 'gradlew');
+    // 1. Ensure gradle-wrapper.jar exists
+    if (!fs.existsSync(wrapperJarPath)) {
+        await ensureWrapperJar(wrapperJarPath);
+    }
+    // 2. Write gradlew script (Shell) - Full standard script
+    if (!fs.existsSync(gradlewPath)) {
+        await fs.writeFile(gradlewPath, GRADLEW_SCRIPT.trim(), { mode: 0o755 });
+    }
+    // 3. Make executable
+    await fs.chmod(gradlewPath, 0o755);
+    // 4. Verify Wrapper (Dry Run)
+    logger.info(`Verifying Gradle setup...`);
+    try {
+        await execa(gradlewPath, ['--version'], { cwd: projectPath, stdio: 'inherit' });
+        logger.success('Gradle wrapper verified.');
+    }
+    catch (e) {
+        logger.warn('Gradle wrapper verification failed. You may need to run it manually.');
+    }
+}
+async function ensureWrapperJar(destPath) {
+    logger.step('Downloading gradle-wrapper.jar...');
+    // Reliable source from Google's sample
+    const WRAPPER_URL = 'https://raw.githubusercontent.com/android/nowinandroid/main/gradle/wrapper/gradle-wrapper.jar';
+    try {
+        const response = await fetch(WRAPPER_URL);
+        if (!response.ok)
+            throw new Error(`Failed to fetch wrapper jar: ${response.statusText}`);
+        if (!response.body)
+            throw new Error('No body in response');
+        await pipeline(response.body, createWriteStream(destPath));
+    }
+    catch (e) {
+        throw new Error(`Failed to download gradle-wrapper.jar. Error: ${e.message}`);
+    }
+}
+// Standard POSIX gradlew script (simplified but fully functional variant)
+const GRADLEW_SCRIPT = `#!/bin/sh
+
+#
+# Copyright 2015 the original author or authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+##############################################################################
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+##############################################################################
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=\`ls -ld "$PRG"\`
+    link=\`expr "$ls" : '.*-> \\(.*\\)$'\`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=\`dirname "$PRG"\`"/$link"
+    fi
+done
+SAVED="$\`pwd\`"
+cd "\`dirname \\"$PRG\\"\`/" >/dev/null
+APP_HOME="\`pwd -P\`"
+cd "$SAVED" >/dev/null
+
+APP_NAME="Gradle"
+APP_BASE_NAME=\`basename "$0"\`
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS=""
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn () {
+    echo "$*"
+}
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "\`uname\`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+  NONSTOP* )
+    nonstop=true
+    ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+        JAVACMD="$JAVA_HOME/bin/java"
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD="java"
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
+    MAX_FD_LIMIT=\`ulimit -H -n\`
+    if [ $? -eq 0 ] ; then
+        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+            MAX_FD="$MAX_FD_LIMIT"
+        fi
+        ulimit -n $MAX_FD
+        if [ $? -ne 0 ] ; then
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
+        fi
+    else
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+    fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+    GRADLE_OPTS="$GRADLE_OPTS \\"-Xdock:name=$APP_NAME\\" \\"-Xdock:icon=$APP_HOME/media/gradle.icns\\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
+    APP_HOME=\`cygpath --path --mixed "$APP_HOME"\`
+    CLASSPATH=\`cygpath --path --mixed "$CLASSPATH"\`
+    JAVACMD=\`cygpath --unix "$JAVACMD"\`
+
+    # We build the pattern for arguments to be converted via cygpath
+    ROOTDIRSRAW=\`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null\`
+    SEP=""
+    for dir in $ROOTDIRSRAW ; do
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
+        SEP="|"
+    done
+    OURCYGPATTERN="(^($ROOTDIRS))"
+    # Add a user-defined pattern to the cygpath arguments
+    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+    fi
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    i=0
+    for arg in "$@" ; do
+        CHECK=\`echo "$arg"|egrep -c "$OURCYGPATTERN" - \`
+        CHECK2=\`echo "$arg"|egrep -c "^-"\`                                 ### Determine if an option
+
+        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
+            eval \`echo args$i\`=\`cygpath --path --ignore --mixed "$arg"\`
+        else
+            eval \`echo args$i\`="\\"$arg\\""
+        fi
+        i=$((i+1))
+    done
+    case $i in
+        (0) set -- ;;
+        (1) set -- "$args0" ;;
+        (2) set -- "$args0" "$args1" ;;
+        (3) set -- "$args0" "$args1" "$args2" ;;
+        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
+fi
+
+# Escape application args
+save () {
+    for i do printf %s\\\\n "$i" | sed "s/'/'\\\\\\\\''/g;1s/^/'/;\$s/\$/' \\\\\\\\/" ; done
+    echo " "
+}
+APP_ARGS=$(save "$@")
+
+# Collect all arguments for the java command, following the shell quoting and substitution rules
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\\"-Dorg.gradle.appname=$APP_BASE_NAME\\"" -classpath "\\"$CLASSPATH\\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+
+exec "$JAVACMD" "$@"
+`;

package/dist/index.js

@@ -0,0 +1,60 @@
+import prompts from 'prompts';
+import { logger } from './utils/logger.js';
+import { checkEnv } from './env/checkEnv.js';
+import { installSdk } from './sdk/installSdk.js';
+import { generateProject } from './template/generateProject.js';
+import { setupGradle } from './gradle/setupGradle.js';
+import path from 'path';
+export async function run(args) {
+    logger.banner();
+    // 1. Collect Input
+    let targetDir = args[0];
+    const defaultProjectName = targetDir || 'android-app';
+    const response = await prompts([
+        {
+            type: targetDir ? null : 'text',
+            name: 'projectName',
+            message: 'Project name:',
+            initial: defaultProjectName
+        },
+        {
+            type: 'select',
+            name: 'uiType',
+            message: 'Select UI Framework:',
+            choices: [
+                { title: 'Jetpack Compose (Recommended)', value: 'compose' },
+                { title: 'XML Views (Legacy)', value: 'views' }
+            ],
+            initial: 0
+        }
+    ], {
+        onCancel: () => {
+            logger.error('Operation cancelled');
+            process.exit(0);
+        }
+    });
+    const projectName = response.projectName || targetDir;
+    const projectPath = path.resolve(process.cwd(), projectName);
+    const uiType = response.uiType;
+    // 2. Validate Environment
+    logger.step('Checking Environment...');
+    await checkEnv();
+    // 3. Setup Android SDK
+    logger.step('Setting up Android SDK...');
+    const sdkPath = await installSdk();
+    // 4. Generate Project Files
+    logger.step(`Scaffolding project in ${projectName}...`);
+    await generateProject({
+        projectPath,
+        projectName,
+        uiType,
+        sdkPath
+    });
+    // 5. Setup Gradle Wrapper
+    logger.step('Configuring Gradle...');
+    await setupGradle(projectPath);
+    logger.success(`Project created at ${projectPath}`);
+    logger.info('To get started:');
+    console.log(`  cd ${projectName}`);
+    console.log(`  ./gradlew installDebug`);
+}

package/dist/sdk/installSdk.js

@@ -0,0 +1,112 @@
+import path from 'path';
+import os from 'os';
+import fs from 'fs-extra';
+import { CONSTANTS } from '../utils/constants.js';
+import { logger } from '../utils/logger.js';
+import { execa } from 'execa';
+import { pipeline } from 'stream/promises';
+import { createWriteStream } from 'fs';
+import AdmZip from 'adm-zip';
+export async function installSdk() {
+    const isMac = process.platform === 'darwin';
+    // 1. Determine SDK Path
+    const sdkPath = process.env.ANDROID_HOME || path.join(os.homedir(), '.local', 'share', 'create-android-app', 'sdk');
+    if (process.env.ANDROID_HOME) {
+        logger.info(`Using ANDROID_HOME: ${sdkPath}`);
+    }
+    else {
+        logger.info(`Using local SDK path: ${sdkPath}`);
+    }
+    await fs.ensureDir(sdkPath);
+    // 2. Check for cmdline-tools
+    const cmdlineToolsRoot = path.join(sdkPath, 'cmdline-tools');
+    const cmdlineToolsLatest = path.join(cmdlineToolsRoot, 'latest');
+    const sdkManagerPath = path.join(cmdlineToolsLatest, 'bin', 'sdkmanager');
+    if (!fs.existsSync(sdkManagerPath)) {
+        logger.step('Android Command Line Tools not found. Downloading...');
+        await downloadCmdlineTools(sdkPath, cmdlineToolsLatest, isMac);
+    }
+    else {
+        logger.success('Command Line Tools found.');
+    }
+    // 3. Accept Licenses (Robust Approach: File Injection)
+    // Instead of piping 'yes', we write known hashes.
+    // These hashes correspond to standard Android SDK licenses.
+    // Source: common knowledge in Android community + verification.
+    const licensesDir = path.join(sdkPath, 'licenses');
+    await fs.ensureDir(licensesDir);
+    const androidSdkLicense = [
+        '8933bad161af4178b1185d1a37fbf41ea5269c55',
+        'd56f5187479451eabf01fb78af6dfcb131a6481e',
+        '24333f8a63b6825ea9c5514f83c2829b004d1fee',
+    ].join('\n');
+    const androidSdkPreviewLicense = '84831b9409646a918e30573bab4c9c91346d8abd';
+    logger.step('Writing license files...');
+    await fs.writeFile(path.join(licensesDir, 'android-sdk-license'), androidSdkLicense);
+    await fs.writeFile(path.join(licensesDir, 'android-sdk-preview-license'), androidSdkPreviewLicense);
+    // 4. Install Packages
+    logger.step('Installing SDK packages (this may take a while)...');
+    const packages = CONSTANTS.SDK_PACKAGES;
+    try {
+        // With licenses pre-accepted, we just run sdkmanager directly.
+        // Use --verbose to verify output if needed, but keep it clean for user unless debug.
+        // Check if packages are already installed to skip slow process?
+        // sdkmanager is slow. If platforms/android-34 exists, maybe skip?
+        const platformCheck = path.join(sdkPath, 'platforms', 'android-34');
+        const buildToolsCheck = path.join(sdkPath, 'build-tools', '34.0.0');
+        if (fs.existsSync(platformCheck) && fs.existsSync(buildToolsCheck)) {
+            logger.success('SDK packages appear to be installed. Skipping redundant install.');
+        }
+        else {
+            await execa(sdkManagerPath, [`--sdk_root=${sdkPath}`, ...packages], {
+                stdio: 'inherit', // Let user see progress bars from sdkmanager
+                env: {
+                    ANDROID_HOME: sdkPath,
+                    // Ensure JAVA_HOME is picked up if set, usually execa inherits env
+                }
+            });
+            logger.success('SDK packages installed.');
+        }
+    }
+    catch (e) {
+        logger.error('Failed to install SDK packages.');
+        logger.error(e.message);
+        throw e; // Fail hard if SDK setup fails
+    }
+    return sdkPath;
+}
+async function downloadCmdlineTools(sdkPath, targetDir, isMac) {
+    const url = isMac ? CONSTANTS.CMDLINE_TOOLS_URL_MAC
+        : CONSTANTS.CMDLINE_TOOLS_URL_LINUX;
+    const zipPath = path.join(sdkPath, 'cmdline-tools.zip');
+    logger.info(`Downloading ${url}...`);
+    const response = await fetch(url);
+    if (!response.ok)
+        throw new Error(`Failed to download SDK: ${response.statusText}`);
+    if (!response.body)
+        throw new Error('No body in response');
+    await pipeline(response.body, createWriteStream(zipPath));
+    logger.info('Extracting (using adm-zip)...');
+    // Extract to temp folder
+    const tempDir = path.join(sdkPath, 'temp_extract');
+    await fs.ensureDir(tempDir);
+    const zip = new AdmZip(zipPath);
+    zip.extractAllTo(tempDir, true); // overwrite: true
+    // Structure: tempDir/cmdline-tools/...
+    // We need to find the root folder inside tempDir
+    const extractedContents = await fs.readdir(tempDir);
+    const rootFolder = extractedContents.find(f => fs.statSync(path.join(tempDir, f)).isDirectory());
+    if (!rootFolder)
+        throw new Error('Unknown zip structure');
+    const source = path.join(tempDir, rootFolder); // usually 'cmdline-tools'
+    // Move to targetDir (which is sdk/cmdline-tools/latest)
+    // Ensure parent exists
+    await fs.ensureDir(path.dirname(targetDir));
+    if (fs.existsSync(targetDir)) {
+        await fs.remove(targetDir);
+    }
+    await fs.move(source, targetDir);
+    // Cleanup
+    await fs.remove(tempDir);
+    await fs.remove(zipPath);
+}

package/dist/template/generateProject.js

@@ -0,0 +1,109 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { CONSTANTS } from '../utils/constants.js';
+import { logger } from '../utils/logger.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export async function generateProject(options) {
+    const { projectPath, projectName, uiType, sdkPath } = options;
+    // 1. Ensure target directory
+    await fs.ensureDir(projectPath);
+    // 2. Resolve template paths
+    const templateRoot = path.resolve(__dirname, '../../templates');
+    const baseTemplate = path.join(templateRoot, 'base');
+    const uiTemplateName = uiType === 'compose' ? 'ui-compose' : 'ui-views';
+    const uiTemplate = path.join(templateRoot, uiTemplateName);
+    if (!fs.existsSync(baseTemplate)) {
+        throw new Error(`Template not found at ${baseTemplate}`);
+    }
+    // 3. Copy Base
+    logger.info(`Copying base template from ${baseTemplate}...`);
+    await fs.copy(baseTemplate, projectPath);
+    // 4. Copy UI specific files
+    if (fs.existsSync(uiTemplate)) {
+        logger.info(`Applying ${uiType} template...`);
+        await fs.copy(uiTemplate, projectPath, { overwrite: true });
+    }
+    // 5. Patch Configuration
+    logger.info(`Patching configuration...`);
+    const packageName = `com.example.${projectName.toLowerCase().replace(/[^a-z0-9]/g, '')}`;
+    // Replace in settings.gradle.kts
+    await patchFile(path.join(projectPath, 'settings.gradle.kts'), {
+        '{{PROJECT_NAME}}': projectName,
+    });
+    // Replace in app/build.gradle.kts
+    await patchFile(path.join(projectPath, 'app/build.gradle.kts'), {
+        '{{APPLICATION_ID}}': packageName,
+        '{{COMPILE_SDK}}': CONSTANTS.COMPILE_SDK.toString(),
+        '{{MIN_SDK}}': CONSTANTS.MIN_SDK.toString(),
+        '{{TARGET_SDK}}': CONSTANTS.TARGET_SDK.toString(),
+    });
+    // Replace in app/src/main/res/values/strings.xml
+    await patchFile(path.join(projectPath, 'app/src/main/res/values/strings.xml'), {
+        '{{PROJECT_NAME}}': projectName,
+    });
+    // Handle Source Code Relocation
+    const srcBase = path.join(projectPath, 'app/src/main/java');
+    const oldPackagePath = path.join(srcBase, 'com/example/template');
+    const newPackagePath = path.join(srcBase, ...packageName.split('.'));
+    if (fs.existsSync(oldPackagePath)) {
+        await fs.move(oldPackagePath, newPackagePath, { overwrite: true });
+        // Recursive file patching for package statement
+        await patchSourceFiles(newPackagePath, packageName);
+        // Clean up empty dirs (com/example/template -> com/example -> com)
+        // Only if empty.
+        await cleanEmptyDirs(srcBase);
+    }
+    // Create local.properties with SDK location
+    const localProperties = `sdk.dir=${sdkPath}`;
+    await fs.writeFile(path.join(projectPath, 'local.properties'), localProperties);
+}
+async function patchFile(filePath, replacements) {
+    if (!fs.existsSync(filePath))
+        return;
+    let content = await fs.readFile(filePath, 'utf-8');
+    for (const [key, value] of Object.entries(replacements)) {
+        content = content.replaceAll(key, value);
+    }
+    await fs.writeFile(filePath, content);
+}
+async function patchSourceFiles(dir, packageName) {
+    const files = await fs.readdir(dir);
+    for (const file of files) {
+        const fullPath = path.join(dir, file);
+        const stat = await fs.stat(fullPath);
+        if (stat.isDirectory()) {
+            await patchSourceFiles(fullPath, packageName);
+        }
+        else if (file.endsWith('.kt') || file.endsWith('.java')) {
+            await patchFile(fullPath, {
+                '{{PACKAGE_NAME}}': packageName
+            });
+        }
+    }
+}
+async function cleanEmptyDirs(dir) {
+    // Basic cleanup: remove com/example/template if empty
+    // We moved content from com/example/template to new path.
+    // So we check if com/example/template is empty, then com/example, then com.
+    // This is tricky because we don't know the exact depth of the old structure easily without hardcoding.
+    // Hardcoded for "com/example/template":
+    const oldPath = path.join(dir, 'com/example/template');
+    try {
+        if (fs.existsSync(oldPath) && (await fs.readdir(oldPath)).length === 0) {
+            await fs.rmdir(oldPath);
+            const parent = path.dirname(oldPath);
+            if ((await fs.readdir(parent)).length === 0) {
+                await fs.rmdir(parent);
+                const grandParent = path.dirname(parent);
+                if ((await fs.readdir(grandParent)).length === 0) {
+                    await fs.rmdir(grandParent);
+                }
+            }
+        }
+    }
+    catch (e) {
+        // Ignore errors during cleanup
+    }
+}

package/dist/utils/constants.js

@@ -0,0 +1,24 @@
+// The "Truth" - Pinned versions for stability
+export const CONSTANTS = {
+    // Tooling
+    JAVA_VERSION_REQ: 17,
+    NODE_VERSION_REQ: 18,
+    // Android SDK
+    CMDLINE_TOOLS_URL_LINUX: "https://dl.google.com/android/repository/commandlinetools-linux-11076708_latest.zip",
+    CMDLINE_TOOLS_URL_MAC: "https://dl.google.com/android/repository/commandlinetools-mac-11076708_latest.zip",
+    SDK_PACKAGES: [
+        "platform-tools",
+        "platforms;android-34",
+        "build-tools;34.0.0",
+        "cmdline-tools;latest"
+    ],
+    // Template Defaults
+    COMPILE_SDK: 34,
+    TARGET_SDK: 34,
+    MIN_SDK: 24,
+    KOTLIN_VERSION: "1.9.23",
+    COMPOSE_COMPILER_EXTENSION_VERSION: "1.5.11",
+    AGP_VERSION: "8.3.2",
+    // Gradle
+    GRADLE_VERSION: "8.7"
+};

package/dist/utils/logger.js

@@ -0,0 +1,14 @@
+import kleur from 'kleur';
+export const logger = {
+    info: (msg) => console.log(kleur.blue('ℹ') + ' ' + msg),
+    success: (msg) => console.log(kleur.green('✔') + ' ' + msg),
+    warn: (msg) => console.log(kleur.yellow('⚠') + ' ' + msg),
+    error: (msg) => console.error(kleur.red('✖') + ' ' + msg),
+    step: (msg) => console.log(kleur.cyan('→') + ' ' + msg),
+    // Minimal "Vite-like" output
+    banner: () => {
+        console.log();
+        console.log(kleur.bgGreen().black(' CREATE-DROID '));
+        console.log();
+    }
+};

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "create-droid",
+  "version": "1.0.0",
+  "description": "The fastest way to start an Android project. No Studio required.",
+  "author": "YELrhilassi",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/YELrhilassi/create-android-app.git"
+  },
+  "keywords": [
+    "android",
+    "kotlin",
+    "compose",
+    "cli",
+    "create-droid",
+    "scaffold",
+    "mobile"
+  ],
+  "bin": {
+    "create-droid": "bin/cli.js"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "templates"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "main": "dist/index.js",
+  "type": "module",
+  "dependencies": {
+    "adm-zip": "^0.5.16",
+    "execa": "^9.6.1",
+    "fs-extra": "^11.3.3",
+    "kleur": "^4.1.5",
+    "prompts": "^2.4.2",
+    "tar": "^7.5.9"
+  },
+  "devDependencies": {
+    "@types/adm-zip": "^0.5.7",
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^25.2.3",
+    "@types/prompts": "^2.4.9",
+    "@types/tar": "^6.1.13",
+    "typescript": "^5.9.3"
+  }
+}

package/templates/base/app/proguard-rules.pro

@@ -0,0 +1,3 @@
+# Add project specific ProGuard rules here.
+# By default, the flags in this file are appended to flags specified
+# in 'proguard-android-optimize.txt' which is shipped with the Android SDK.

package/templates/base/build.gradle.kts

@@ -0,0 +1,5 @@
+// Top-level build file where you can add configuration options common to all sub-projects/modules.
+plugins {
+    alias(libs.plugins.android.application) apply false
+    alias(libs.plugins.jetbrains.kotlin.android) apply false
+}

package/templates/base/gradle/libs.versions.toml

@@ -0,0 +1,34 @@
+[versions]
+agp = "8.3.2"
+kotlin = "1.9.23"
+coreKtx = "1.12.0"
+junit = "4.13.2"
+junitVersion = "1.1.5"
+espressoCore = "3.5.1"
+lifecycleRuntimeKtx = "2.7.0"
+activityCompose = "1.8.2"
+composeBom = "2024.02.01"
+appcompat = "1.6.1"
+material = "1.11.0"
+
+[libraries]
+androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref = "coreKtx" }
+junit = { group = "junit", name = "junit", version.ref = "junit" }
+androidx-junit = { group = "androidx.test.ext", name = "junit", version.ref = "junitVersion" }
+androidx-espresso-core = { group = "androidx.test.espresso", name = "espresso-core", version.ref = "espressoCore" }
+androidx-lifecycle-runtime-ktx = { group = "androidx.lifecycle", name = "lifecycle-runtime-ktx", version.ref = "lifecycleRuntimeKtx" }
+androidx-activity-compose = { group = "androidx.activity", name = "activity-compose", version.ref = "activityCompose" }
+androidx-compose-bom = { group = "androidx.compose", name = "compose-bom", version.ref = "composeBom" }
+androidx-ui = { group = "androidx.compose.ui", name = "ui" }
+androidx-ui-graphics = { group = "androidx.compose.ui", name = "ui-graphics" }
+androidx-ui-tooling = { group = "androidx.compose.ui", name = "ui-tooling" }
+androidx-ui-tooling-preview = { group = "androidx.compose.ui", name = "ui-tooling-preview" }
+androidx-ui-test-manifest = { group = "androidx.compose.ui", name = "ui-test-manifest" }
+androidx-ui-test-junit4 = { group = "androidx.compose.ui", name = "ui-test-junit4" }
+androidx-material3 = { group = "androidx.compose.material3", name = "material3" }
+androidx-appcompat = { group = "androidx.appcompat", name = "appcompat", version.ref = "appcompat" }
+material = { group = "com.google.android.material", name = "material", version.ref = "material" }
+
+[plugins]
+android-application = { id = "com.android.application", version.ref = "agp" }
+jetbrains-kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }

package/templates/base/gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,5 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.7-bin.zip
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists

package/templates/base/gradle.properties

@@ -0,0 +1,4 @@
+org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8
+android.useAndroidX=true
+kotlin.code.style=official
+android.nonTransitiveRClass=true

package/templates/base/settings.gradle.kts

@@ -0,0 +1,23 @@
+pluginManagement {
+    repositories {
+        google {
+            content {
+                includeGroupByRegex("com\\.android.*")
+                includeGroupByRegex("com\\.google.*")
+                includeGroupByRegex("androidx.*")
+            }
+        }
+        mavenCentral()
+        gradlePluginPortal()
+    }
+}
+dependencyResolutionManagement {
+    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
+    repositories {
+        google()
+        mavenCentral()
+    }
+}
+
+rootProject.name = "{{PROJECT_NAME}}"
+include(":app")

package/templates/ui-compose/app/build.gradle.kts

@@ -0,0 +1,65 @@
+plugins {
+    alias(libs.plugins.android.application)
+    alias(libs.plugins.jetbrains.kotlin.android)
+}
+
+android {
+    namespace = "{{APPLICATION_ID}}"
+    compileSdk = {{COMPILE_SDK}}
+
+    defaultConfig {
+        applicationId = "{{APPLICATION_ID}}"
+        minSdk = {{MIN_SDK}}
+        targetSdk = {{TARGET_SDK}}
+        versionCode = 1
+        versionName = "1.0"
+
+        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+        vectorDrawables {
+            useSupportLibrary = true
+        }
+    }
+
+    buildTypes {
+        release {
+            isMinifyEnabled = false
+            proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro")
+        }
+    }
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_1_8
+        targetCompatibility = JavaVersion.VERSION_1_8
+    }
+    kotlinOptions {
+        jvmTarget = "1.8"
+    }
+    buildFeatures {
+        compose = true
+    }
+    composeOptions {
+        kotlinCompilerExtensionVersion = "1.5.11"
+    }
+    packaging {
+        resources {
+            excludes += "/META-INF/{AL2.0,LGPL2.1}"
+        }
+    }
+}
+
+dependencies {
+    implementation(libs.androidx.core.ktx)
+    implementation(libs.androidx.lifecycle.runtime.ktx)
+    implementation(libs.androidx.activity.compose)
+    implementation(platform(libs.androidx.compose.bom))
+    implementation(libs.androidx.ui)
+    implementation(libs.androidx.ui.graphics)
+    implementation(libs.androidx.ui.tooling.preview)
+    implementation(libs.androidx.material3)
+    testImplementation(libs.junit)
+    androidTestImplementation(libs.androidx.junit)
+    androidTestImplementation(libs.androidx.espresso.core)
+    androidTestImplementation(platform(libs.androidx.compose.bom))
+    androidTestImplementation(libs.androidx.ui.test.junit4)
+    debugImplementation(libs.androidx.ui.tooling)
+    debugImplementation(libs.androidx.ui.test.manifest)
+}

package/templates/ui-compose/app/src/main/AndroidManifest.xml

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools">
+
+    <application
+        android:allowBackup="true"
+        android:dataExtractionRules="@xml/data_extraction_rules"
+        android:fullBackupContent="@xml/backup_rules"
+        android:icon="@mipmap/ic_launcher"
+        android:label="@string/app_name"
+        android:roundIcon="@mipmap/ic_launcher_round"
+        android:supportsRtl="true"
+        android:theme="@style/Theme.MyApplication"
+        tools:targetApi="31">
+        <activity
+            android:name=".MainActivity"
+            android:exported="true"
+            android:label="@string/app_name"
+            android:theme="@style/Theme.MyApplication">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+
+</manifest>

package/templates/ui-compose/app/src/main/java/com/example/template/MainActivity.kt

@@ -0,0 +1,46 @@
+package {{PACKAGE_NAME}}
+
+import android.os.Bundle
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.setContent
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.tooling.preview.Preview
+
+class MainActivity : ComponentActivity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContent {
+            MaterialTheme {
+                Surface(
+                    modifier = Modifier.fillMaxSize(),
+                    color = MaterialTheme.colorScheme.background
+                ) {
+                    Greeting("Android")
+                }
+            }
+        }
+    }
+}
+
+@Composable
+fun Greeting(name: String, modifier: Modifier = Modifier) {
+    Text(
+        text = "Hello $name!",
+        modifier = modifier
+    )
+}
+
+@Preview(showBackground = true)
+@Composable
+fun GreetingPreview() {
+    MaterialTheme {
+        Greeting("Android")
+    }
+}

package/templates/ui-views/app/build.gradle.kts

@@ -0,0 +1,44 @@
+plugins {
+    alias(libs.plugins.android.application)
+    alias(libs.plugins.jetbrains.kotlin.android)
+}
+
+android {
+    namespace = "{{APPLICATION_ID}}"
+    compileSdk = {{COMPILE_SDK}}
+
+    defaultConfig {
+        applicationId = "{{APPLICATION_ID}}"
+        minSdk = {{MIN_SDK}}
+        targetSdk = {{TARGET_SDK}}
+        versionCode = 1
+        versionName = "1.0"
+        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+    }
+
+    buildTypes {
+        release {
+            isMinifyEnabled = false
+            proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro")
+        }
+    }
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_1_8
+        targetCompatibility = JavaVersion.VERSION_1_8
+    }
+    kotlinOptions {
+        jvmTarget = "1.8"
+    }
+    buildFeatures {
+        viewBinding = true
+    }
+}
+
+dependencies {
+    implementation(libs.androidx.core.ktx)
+    implementation(libs.androidx.appcompat)
+    implementation(libs.material)
+    testImplementation(libs.junit)
+    androidTestImplementation(libs.androidx.junit)
+    androidTestImplementation(libs.androidx.espresso.core)
+}

package/templates/ui-views/app/src/main/AndroidManifest.xml

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools">
+
+    <application
+        android:allowBackup="true"
+        android:dataExtractionRules="@xml/data_extraction_rules"
+        android:fullBackupContent="@xml/backup_rules"
+        android:icon="@mipmap/ic_launcher"
+        android:label="@string/app_name"
+        android:roundIcon="@mipmap/ic_launcher_round"
+        android:supportsRtl="true"
+        android:theme="@style/Theme.MyApplication"
+        tools:targetApi="31">
+        <activity
+            android:name=".MainActivity"
+            android:exported="true"
+            android:label="@string/app_name"
+            android:theme="@style/Theme.MyApplication">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+
+</manifest>

package/templates/ui-views/app/src/main/java/com/example/template/MainActivity.kt

@@ -0,0 +1,19 @@
+package {{PACKAGE_NAME}}
+
+import android.os.Bundle
+import androidx.appcompat.app.AppCompatActivity
+import {{PACKAGE_NAME}}.databinding.ActivityMainBinding
+
+class MainActivity : AppCompatActivity() {
+
+    private lateinit var binding: ActivityMainBinding
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        
+        binding = ActivityMainBinding.inflate(layoutInflater)
+        setContentView(binding.root)
+
+        binding.textView.text = "Hello Android!"
+    }
+}

package/templates/ui-views/app/src/main/res/layout/activity_main.xml

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    tools:context=".MainActivity">
+
+    <TextView
+        android:id="@+id/textView"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:text="Hello World!"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:layout_constraintStart_toStartOf="parent"
+        app:layout_constraintTop_toTopOf="parent" />
+
+</androidx.constraintlayout.widget.ConstraintLayout>