optikit 1.1.1 → 1.2.0

package/dist/commands/buildReleases.js

@@ -1,83 +1,57 @@
-import { execCommand } from "../utils/execHelpers.js";
-import { LoggerHelpers } from "../utils/loggerHelpers.js";
+import { executeBuild } from "../utils/buildHelpers.js";
+import { BUILD_CONFIGS } from "../constants.js";
 export { buildFlutterApk, buildFlutterBundle, buildFlutterIos, buildFlutterIpa, };
+/**
+ * Builds Flutter APK with release configuration, obfuscation, and split debug info
+ * @param noFvm - Whether to disable FVM usage
+ */
 async function buildFlutterApk(noFvm) {
-    LoggerHelpers.info(noFvm
-        ? "Building Flutter APK without FVM..."
-        : "Building Flutter APK with FVM...");
-    const command = noFvm
-        ? "flutter build apk --release --obfuscate --split-debug-info=build/app/outputs/symbols"
-        : "fvm flutter build apk --release --obfuscate --split-debug-info=build/app/outputs/symbols";
-    try {
-        await execCommand(command);
-        LoggerHelpers.success("Flutter APK build successful.");
-    }
-    catch (error) {
-        if (error instanceof Error) {
-            LoggerHelpers.error(`Error during APK build: ${error.message}`);
-        }
-        else {
-            LoggerHelpers.error(`Error during APK build: ${error}`);
-        }
-    }
+    await executeBuild({
+        type: "APK",
+        command: "flutter build apk",
+        flags: [
+            ...BUILD_CONFIGS.APK.flags,
+            `--split-debug-info=${BUILD_CONFIGS.APK.outputPath}`,
+        ],
+        requireAndroid: true,
+    }, noFvm);
 }
+/**
+ * Builds Flutter App Bundle with release configuration, obfuscation, and split debug info
+ * @param noFvm - Whether to disable FVM usage
+ */
 async function buildFlutterBundle(noFvm) {
-    LoggerHelpers.info(noFvm
-        ? "Building Flutter Bundle without FVM..."
-        : "Building Flutter Bundle with FVM...");
-    const command = noFvm
-        ? "flutter build appbundle --release --obfuscate --split-debug-info=build/app/outputs/symbols"
-        : "fvm flutter build appbundle --release --obfuscate --split-debug-info=build/app/outputs/symbols";
-    try {
-        await execCommand(command);
-        LoggerHelpers.success("Flutter Bundle build successful.");
-    }
-    catch (error) {
-        if (error instanceof Error) {
-            LoggerHelpers.error(`Error during Bundle build: ${error.message}`);
-        }
-        else {
-            LoggerHelpers.error(`Error during Bundle build: ${error}`);
-        }
-    }
+    await executeBuild({
+        type: "Bundle",
+        command: "flutter build appbundle",
+        flags: [
+            ...BUILD_CONFIGS.BUNDLE.flags,
+            `--split-debug-info=${BUILD_CONFIGS.BUNDLE.outputPath}`,
+        ],
+        requireAndroid: true,
+    }, noFvm);
 }
+/**
+ * Builds Flutter iOS app with release configuration
+ * @param noFvm - Whether to disable FVM usage
+ */
 async function buildFlutterIos(noFvm) {
-    LoggerHelpers.info(noFvm
-        ? "Building Flutter iOS app without FVM..."
-        : "Building Flutter iOS app with FVM...");
-    const command = noFvm
-        ? "flutter build ios --release"
-        : "fvm flutter build ios --release";
-    try {
-        await execCommand(command);
-        LoggerHelpers.success("Flutter iOS app build successful.");
-    }
-    catch (error) {
-        if (error instanceof Error) {
-            LoggerHelpers.error(`Error during iOS build: ${error.message}`);
-        }
-        else {
-            LoggerHelpers.error(`Error during iOS build: ${error}`);
-        }
-    }
+    await executeBuild({
+        type: "iOS app",
+        command: "flutter build ios",
+        flags: [...BUILD_CONFIGS.IOS.flags],
+        requireIos: true,
+    }, noFvm);
 }
+/**
+ * Creates release IPA with updated build version number
+ * @param noFvm - Whether to disable FVM usage
+ */
 async function buildFlutterIpa(noFvm) {
-    LoggerHelpers.info(noFvm
-        ? "Creating release IPA without FVM..."
-        : "Creating release IPA with FVM...");
-    const command = noFvm
-        ? "flutter build ipa --release"
-        : "fvm flutter build ipa --release";
-    try {
-        await execCommand(command);
-        LoggerHelpers.success("Release IPA creation successful.");
-    }
-    catch (error) {
-        if (error instanceof Error) {
-            LoggerHelpers.error(`Error during IPA creation: ${error.message}`);
-        }
-        else {
-            LoggerHelpers.error(`Error during IPA creation: ${error}`);
-        }
-    }
+    await executeBuild({
+        type: "IPA",
+        command: "flutter build ipa",
+        flags: [...BUILD_CONFIGS.IPA.flags],
+        requireIos: true,
+    }, noFvm);
 }

package/dist/commands/clean/flutter.js

@@ -0,0 +1,51 @@
+import fs from "fs";
+import path from "path";
+import { execCommand } from "../../utils/services/exec.js";
+import { LoggerHelpers } from "../../utils/services/logger.js";
+import { validateFlutterProject, validateFlutterSdk } from "../../utils/validators/validation.js";
+import { createBackup } from "../../utils/services/backup.js";
+export { cleanProject };
+async function cleanProject(noFvm) {
+    LoggerHelpers.info(noFvm ? "Running clean without FVM..." : "Running clean with FVM...");
+    // Pre-flight validation
+    if (!validateFlutterProject()) {
+        process.exit(1);
+    }
+    if (!(await validateFlutterSdk(!noFvm))) {
+        process.exit(1);
+    }
+    try {
+        // Step 1: Run flutter clean
+        const flutterCommand = noFvm ? "flutter clean" : "fvm flutter clean";
+        LoggerHelpers.info("Running Flutter clean...");
+        await execCommand(flutterCommand);
+        LoggerHelpers.success("Flutter clean completed.");
+        // Step 2: Remove pubspec.lock using Node.js fs (cross-platform)
+        const pubspecLockPath = path.join(process.cwd(), "pubspec.lock");
+        if (fs.existsSync(pubspecLockPath)) {
+            LoggerHelpers.info("Removing pubspec.lock...");
+            // Create backup before deletion
+            createBackup(pubspecLockPath);
+            fs.unlinkSync(pubspecLockPath);
+            LoggerHelpers.success("pubspec.lock removed.");
+        }
+        else {
+            LoggerHelpers.info("pubspec.lock does not exist, skipping removal.");
+        }
+        // Step 3: Run flutter pub get
+        const pubGetCommand = noFvm ? "flutter pub get" : "fvm flutter pub get";
+        LoggerHelpers.info("Running Flutter pub get...");
+        await execCommand(pubGetCommand);
+        LoggerHelpers.success("Flutter pub get completed.");
+        LoggerHelpers.success("Project cleaned successfully.");
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            LoggerHelpers.error(`Error during clean: ${error.message}`);
+        }
+        else {
+            LoggerHelpers.error(`Error during clean: ${error}`);
+        }
+        process.exit(1);
+    }
+}

package/dist/commands/clean/ios.js

@@ -0,0 +1,109 @@
+import * as fs from "fs";
+import * as path from "path";
+import { LoggerHelpers } from "../../utils/services/logger.js";
+import { execInIos, execCommand, iosDirectory, execInIosWithRetry } from "../../utils/services/exec.js";
+import { validateFlutterProject, validateIosProject } from "../../utils/validators/validation.js";
+export { cleanIosProject };
+async function getFlutterSdkPath() {
+    const fvmDir = path.join(process.cwd(), ".fvm", "flutter_sdk");
+    if (fs.existsSync(fvmDir)) {
+        LoggerHelpers.info(`Using FVM Flutter SDK...`);
+        return fvmDir;
+    }
+    const command = "which flutter";
+    try {
+        const globalFlutterPath = await execCommand(command);
+        LoggerHelpers.info("Using Flutter SDK...");
+        return path.dirname(globalFlutterPath.trim());
+    }
+    catch (error) {
+        LoggerHelpers.error("Flutter SDK not found. Please ensure Flutter is installed.");
+        throw error;
+    }
+}
+async function getFlutterXcframeworkPath() {
+    const flutterSdkPath = await getFlutterSdkPath();
+    return path.join(flutterSdkPath, "bin/cache/artifacts/engine/ios/Flutter.xcframework");
+}
+async function ensureFlutterArtifactsExist() {
+    const flutterXcframeworkPath = await getFlutterXcframeworkPath();
+    if (!fs.existsSync(flutterXcframeworkPath)) {
+        LoggerHelpers.warning("Flutter.xcframework not found.");
+        try {
+            LoggerHelpers.info("Downloading Flutter.xcframework...");
+            await execCommand("fvm flutter precache --ios");
+            LoggerHelpers.success("Flutter.xcframework has been downloaded successfully.");
+        }
+        catch (error) {
+            LoggerHelpers.error(`Failed to run precache: ${error instanceof Error ? error.message : error}`);
+        }
+    }
+    else {
+        LoggerHelpers.success("Flutter.xcframework exists. No need to run 'fvm flutter precache --ios'.");
+    }
+}
+async function cleanIosProject(cleanCache, repoUpdate) {
+    // Pre-flight validation
+    if (!validateFlutterProject()) {
+        process.exit(1);
+    }
+    if (!validateIosProject()) {
+        process.exit(1);
+    }
+    try {
+        LoggerHelpers.info("Running clean for iOS project...");
+        await ensureFlutterArtifactsExist();
+        LoggerHelpers.info("Removing Podfile.lock...");
+        const podfileLockPath = path.join(iosDirectory, "Podfile.lock");
+        if (fs.existsSync(podfileLockPath)) {
+            fs.unlinkSync(podfileLockPath);
+            LoggerHelpers.success("Removed Podfile.lock.");
+        }
+        else {
+            LoggerHelpers.info("Podfile.lock does not exist, skipping removal.");
+        }
+        LoggerHelpers.info("Deintegrating pods...");
+        await execInIos("pod deintegrate");
+        LoggerHelpers.success("Deintegrated pods.");
+        if (cleanCache) {
+            LoggerHelpers.info("Cleaning CocoaPods cache...");
+            await execInIos("pod cache clean --all");
+            LoggerHelpers.success("Cleaned CocoaPods cache.");
+        }
+        if (repoUpdate) {
+            LoggerHelpers.info("Updating CocoaPods repositories...");
+            try {
+                await execInIosWithRetry("pod repo update", 3, 10000);
+                LoggerHelpers.success("Updated CocoaPods repositories.");
+            }
+            catch (error) {
+                LoggerHelpers.error("Failed to update CocoaPods repositories. Retrying...");
+            }
+            LoggerHelpers.info("Installing pods with repo update...");
+            try {
+                await execInIosWithRetry("pod update", 3, 10000);
+                LoggerHelpers.success("Installed pods with repo update.");
+            }
+            catch (error) {
+                LoggerHelpers.error("Failed to update pods. Retrying...");
+            }
+        }
+        else {
+            LoggerHelpers.info("Installing pods without repo update...");
+            await execInIosWithRetry("pod install", 3, 10000);
+            LoggerHelpers.success("Installed pods without repo update.");
+        }
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            LoggerHelpers.error(`Error: ${error.message}`);
+        }
+        else if (typeof error === "string") {
+            LoggerHelpers.error(`Error: ${error}`);
+        }
+        else {
+            LoggerHelpers.error(`Unknown error: ${JSON.stringify(error)}`);
+        }
+        process.exit(1);
+    }
+}

package/dist/commands/cleanProject.js

@@ -1,13 +1,42 @@
+import fs from "fs";
+import path from "path";
 import { execCommand } from "../utils/execHelpers.js";
 import { LoggerHelpers } from "../utils/loggerHelpers.js";
+import { validateFlutterProject, validateFlutterSdk } from "../utils/validationHelpers.js";
+import { createBackup } from "../utils/backupHelpers.js";
 export { cleanProject };
 async function cleanProject(noFvm) {
     LoggerHelpers.info(noFvm ? "Running clean without FVM..." : "Running clean with FVM...");
-    const command = noFvm
-        ? "flutter clean && rm -rf pubspec.lock && flutter pub get"
-        : "fvm flutter clean && rm -rf pubspec.lock && fvm flutter pub get";
+    // Pre-flight validation
+    if (!validateFlutterProject()) {
+        process.exit(1);
+    }
+    if (!(await validateFlutterSdk(!noFvm))) {
+        process.exit(1);
+    }
     try {
-        await execCommand(command);
+        // Step 1: Run flutter clean
+        const flutterCommand = noFvm ? "flutter clean" : "fvm flutter clean";
+        LoggerHelpers.info("Running Flutter clean...");
+        await execCommand(flutterCommand);
+        LoggerHelpers.success("Flutter clean completed.");
+        // Step 2: Remove pubspec.lock using Node.js fs (cross-platform)
+        const pubspecLockPath = path.join(process.cwd(), "pubspec.lock");
+        if (fs.existsSync(pubspecLockPath)) {
+            LoggerHelpers.info("Removing pubspec.lock...");
+            // Create backup before deletion
+            createBackup(pubspecLockPath);
+            fs.unlinkSync(pubspecLockPath);
+            LoggerHelpers.success("pubspec.lock removed.");
+        }
+        else {
+            LoggerHelpers.info("pubspec.lock does not exist, skipping removal.");
+        }
+        // Step 3: Run flutter pub get
+        const pubGetCommand = noFvm ? "flutter pub get" : "fvm flutter pub get";
+        LoggerHelpers.info("Running Flutter pub get...");
+        await execCommand(pubGetCommand);
+        LoggerHelpers.success("Flutter pub get completed.");
         LoggerHelpers.success("Project cleaned successfully.");
     }
     catch (error) {
@@ -17,5 +46,6 @@ async function cleanProject(noFvm) {
         else {
             LoggerHelpers.error(`Error during clean: ${error}`);
         }
+        process.exit(1);
     }
 }

package/dist/commands/cleanProjectIos.js

@@ -2,6 +2,7 @@ import * as fs from "fs";
 import * as path from "path";
 import { LoggerHelpers } from "../utils/loggerHelpers.js";
 import { execInIos, execCommand, iosDirectory, execInIosWithRetry } from "../utils/execHelpers.js";
+import { validateFlutterProject, validateIosProject } from "../utils/validationHelpers.js";
 export { cleanIosProject };
 async function getFlutterSdkPath() {
     const fvmDir = path.join(process.cwd(), ".fvm", "flutter_sdk");
@@ -42,17 +43,25 @@ async function ensureFlutterArtifactsExist() {
     }
 }
 async function cleanIosProject(cleanCache, repoUpdate) {
+    // Pre-flight validation
+    if (!validateFlutterProject()) {
+        process.exit(1);
+    }
+    if (!validateIosProject()) {
+        process.exit(1);
+    }
     try {
-        const xcodeProjPath = path.join(iosDirectory, "Runner.xcodeproj");
-        if (!fs.existsSync(xcodeProjPath)) {
-            LoggerHelpers.error("No Xcode project found in the ios directory.");
-            return;
-        }
         LoggerHelpers.info("Running clean for iOS project...");
         await ensureFlutterArtifactsExist();
         LoggerHelpers.info("Removing Podfile.lock...");
-        await execInIos("rm -rf Podfile.lock");
-        LoggerHelpers.success("Removed Podfile.lock.");
+        const podfileLockPath = path.join(iosDirectory, "Podfile.lock");
+        if (fs.existsSync(podfileLockPath)) {
+            fs.unlinkSync(podfileLockPath);
+            LoggerHelpers.success("Removed Podfile.lock.");
+        }
+        else {
+            LoggerHelpers.info("Podfile.lock does not exist, skipping removal.");
+        }
         LoggerHelpers.info("Deintegrating pods...");
         await execInIos("pod deintegrate");
         LoggerHelpers.success("Deintegrated pods.");
@@ -95,5 +104,6 @@ async function cleanIosProject(cleanCache, repoUpdate) {
         else {
             LoggerHelpers.error(`Unknown error: ${JSON.stringify(error)}`);
         }
+        process.exit(1);
     }
 }

package/dist/commands/config/init.js

@@ -0,0 +1,54 @@
+import fs from "fs";
+import path from "path";
+import { LoggerHelpers } from "../../utils/services/logger.js";
+import { saveConfig } from "../../utils/services/config.js";
+export { initializeProject };
+/**
+ * Initializes OptiKit in the current project
+ * Creates .optikitrc configuration file with defaults
+ */
+async function initializeProject() {
+    try {
+        LoggerHelpers.info("Initializing OptiKit in this project...");
+        const configPath = path.join(process.cwd(), ".optikitrc.json");
+        // Check if config already exists
+        if (fs.existsSync(configPath)) {
+            LoggerHelpers.warning("OptiKit configuration already exists.");
+            LoggerHelpers.info("To reconfigure, delete .optikitrc.json and run init again.");
+            return;
+        }
+        // Create default configuration
+        const defaultConfig = {
+            backupRetentionCount: 5,
+            useFvmByDefault: false,
+            autoBackup: true,
+            verbose: false,
+        };
+        // Save configuration
+        const success = saveConfig(defaultConfig);
+        if (success) {
+            LoggerHelpers.success("OptiKit initialized successfully!");
+            console.log("\nDefault configuration:");
+            console.log(JSON.stringify(defaultConfig, null, 2));
+            console.log("\nYou can modify .optikitrc.json to customize these settings.\n");
+            // Create .gitignore entry for backups if .gitignore exists
+            const gitignorePath = path.join(process.cwd(), ".gitignore");
+            if (fs.existsSync(gitignorePath)) {
+                const gitignoreContent = fs.readFileSync(gitignorePath, "utf8");
+                if (!gitignoreContent.includes(".optikit-backup")) {
+                    fs.appendFileSync(gitignorePath, "\n# OptiKit backup files\n.optikit-backup/\n");
+                    LoggerHelpers.success("Added .optikit-backup/ to .gitignore");
+                }
+            }
+        }
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            LoggerHelpers.error(`Error initializing project: ${error.message}`);
+        }
+        else {
+            LoggerHelpers.error(`Error initializing project: ${error}`);
+        }
+        process.exit(1);
+    }
+}

package/dist/commands/config/rollback.js

@@ -0,0 +1,161 @@
+import fs from "fs";
+import path from "path";
+import { LoggerHelpers } from "../../utils/services/logger.js";
+import { restoreBackup } from "../../utils/services/backup.js";
+import chalk from "chalk";
+export { rollbackFiles };
+/**
+ * Lists all available backups and allows restoration
+ */
+async function rollbackFiles() {
+    try {
+        LoggerHelpers.info("Searching for OptiKit backups...");
+        const backups = findAllBackups(process.cwd());
+        if (backups.length === 0) {
+            LoggerHelpers.warning("No backups found in this project.");
+            LoggerHelpers.info("Backups are created automatically when files are modified.");
+            return;
+        }
+        console.log(chalk.bold(`\nFound ${backups.length} backup(s):\n`));
+        // Group backups by original file
+        const backupsByFile = new Map();
+        for (const backup of backups) {
+            const originalFile = getOriginalFilePath(backup.backupPath);
+            if (!backupsByFile.has(originalFile)) {
+                backupsByFile.set(originalFile, []);
+            }
+            backupsByFile.get(originalFile).push(backup);
+        }
+        // Display backups grouped by file
+        let index = 1;
+        const backupList = [];
+        for (const [originalFile, fileBackups] of backupsByFile) {
+            console.log(chalk.cyan.bold(`\n${originalFile}`));
+            // Sort by timestamp (newest first)
+            fileBackups.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+            for (const backup of fileBackups) {
+                const timeAgo = getTimeAgo(backup.timestamp);
+                const sizeKB = (backup.size / 1024).toFixed(2);
+                console.log(chalk.gray(`  [${index}]`), chalk.white(backup.timestamp.toLocaleString()), chalk.gray(`(${timeAgo}, ${sizeKB} KB)`));
+                backupList.push({
+                    index,
+                    originalPath: originalFile,
+                    backupPath: backup.backupPath,
+                    timestamp: backup.timestamp,
+                });
+                index++;
+            }
+        }
+        console.log(chalk.yellow("\n" + "=".repeat(60)));
+        console.log(chalk.gray("To restore a backup, run:"));
+        console.log(chalk.white("  optikit rollback --restore <number>"));
+        console.log(chalk.gray("\nExample:"));
+        console.log(chalk.white("  optikit rollback --restore 1"));
+        console.log(chalk.yellow("=".repeat(60) + "\n"));
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            LoggerHelpers.error(`Error listing backups: ${error.message}`);
+        }
+        else {
+            LoggerHelpers.error(`Error listing backups: ${error}`);
+        }
+        process.exit(1);
+    }
+}
+/**
+ * Restores a specific backup by index
+ */
+export async function rollbackRestore(index) {
+    try {
+        const backups = findAllBackups(process.cwd());
+        if (index < 1 || index > backups.length) {
+            LoggerHelpers.error(`Invalid backup index: ${index}`);
+            LoggerHelpers.info(`Please choose a number between 1 and ${backups.length}`);
+            process.exit(1);
+        }
+        const backup = backups[index - 1];
+        const originalPath = getOriginalFilePath(backup.backupPath);
+        LoggerHelpers.info(`Restoring: ${originalPath}`);
+        LoggerHelpers.info(`From backup: ${backup.timestamp.toLocaleString()}`);
+        const success = restoreBackup(originalPath, backup.backupPath);
+        if (success) {
+            LoggerHelpers.success("Backup restored successfully!");
+        }
+        else {
+            LoggerHelpers.error("Failed to restore backup.");
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            LoggerHelpers.error(`Error restoring backup: ${error.message}`);
+        }
+        else {
+            LoggerHelpers.error(`Error restoring backup: ${error}`);
+        }
+        process.exit(1);
+    }
+}
+/**
+ * Recursively finds all backup files in a directory
+ */
+function findAllBackups(dir) {
+    const backups = [];
+    function searchDirectory(currentDir) {
+        const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(currentDir, entry.name);
+            if (entry.isDirectory()) {
+                if (entry.name === ".optikit-backup") {
+                    // Found a backup directory
+                    const backupFiles = fs.readdirSync(fullPath);
+                    for (const backupFile of backupFiles) {
+                        const backupPath = path.join(fullPath, backupFile);
+                        const stats = fs.statSync(backupPath);
+                        backups.push({
+                            backupPath,
+                            timestamp: stats.mtime,
+                            size: stats.size,
+                        });
+                    }
+                }
+                else if (!entry.name.startsWith(".") && entry.name !== "node_modules") {
+                    // Recursively search subdirectories
+                    searchDirectory(fullPath);
+                }
+            }
+        }
+    }
+    searchDirectory(dir);
+    return backups;
+}
+/**
+ * Extracts the original file path from a backup path
+ */
+function getOriginalFilePath(backupPath) {
+    const backupDir = path.dirname(backupPath);
+    const originalDir = path.dirname(backupDir);
+    const backupFileName = path.basename(backupPath);
+    // Remove timestamp from filename
+    // Format: filename_YYYY-MM-DDTHH-MM-SS-mmmZ.ext
+    const match = backupFileName.match(/^(.+)_\d{4}-\d{2}-\d{2}T[\d-]+Z(\.\w+)$/);
+    if (match) {
+        const [, baseName, extension] = match;
+        return path.join(originalDir, `${baseName}${extension}`);
+    }
+    return path.join(originalDir, backupFileName);
+}
+/**
+ * Gets human-readable time ago string
+ */
+function getTimeAgo(date) {
+    const seconds = Math.floor((new Date().getTime() - date.getTime()) / 1000);
+    if (seconds < 60)
+        return `${seconds}s ago`;
+    if (seconds < 3600)
+        return `${Math.floor(seconds / 60)}m ago`;
+    if (seconds < 86400)
+        return `${Math.floor(seconds / 3600)}h ago`;
+    return `${Math.floor(seconds / 86400)}d ago`;
+}

package/dist/commands/generateModule.js

@@ -1,19 +1,47 @@
+import fs from "fs";
 import path from "path";
 import { createDirectories, writeFile, getClassName, } from "../utils/fileHelpers.js";
 import { LoggerHelpers } from "../utils/loggerHelpers.js";
 export { generateModule };
 function generateModule(moduleName) {
-    const modulePath = path.join("lib", "module", moduleName);
-    const directories = ["bloc", "event", "state", "screen", "import", "factory"];
-    createDirectories(modulePath, directories);
-    LoggerHelpers.info(`Creating module structure for ${moduleName}...`);
-    generateBloc(moduleName, path.join(modulePath, "bloc"));
-    generateEvent(moduleName, path.join(modulePath, "event"));
-    generateState(moduleName, path.join(modulePath, "state"));
-    generateScreen(moduleName, path.join(modulePath, "screen"));
-    generateImport(moduleName, path.join(modulePath, "import"));
-    generateStateFactory(moduleName, path.join(modulePath, "factory"));
-    LoggerHelpers.success(`Module ${moduleName} created with full structure.`);
+    try {
+        // Validate module name
+        if (!moduleName || moduleName.trim().length === 0) {
+            LoggerHelpers.error("Module name cannot be empty.");
+            process.exit(1);
+        }
+        // Validate module name format (only lowercase letters, numbers, and underscores)
+        const validNamePattern = /^[a-z0-9_]+$/;
+        if (!validNamePattern.test(moduleName)) {
+            LoggerHelpers.error("Module name must contain only lowercase letters, numbers, and underscores.");
+            process.exit(1);
+        }
+        const modulePath = path.join("lib", "module", moduleName);
+        const directories = ["bloc", "event", "state", "screen", "import", "factory"];
+        // Check if module already exists
+        if (fs.existsSync(modulePath)) {
+            LoggerHelpers.warning(`Module ${moduleName} already exists at ${modulePath}`);
+            LoggerHelpers.info("Files will be overwritten...");
+        }
+        createDirectories(modulePath, directories);
+        LoggerHelpers.info(`Creating module structure for ${moduleName}...`);
+        generateBloc(moduleName, path.join(modulePath, "bloc"));
+        generateEvent(moduleName, path.join(modulePath, "event"));
+        generateState(moduleName, path.join(modulePath, "state"));
+        generateScreen(moduleName, path.join(modulePath, "screen"));
+        generateImport(moduleName, path.join(modulePath, "import"));
+        generateStateFactory(moduleName, path.join(modulePath, "factory"));
+        LoggerHelpers.success(`Module ${moduleName} created with full structure.`);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            LoggerHelpers.error(`Error generating module: ${error.message}`);
+        }
+        else {
+            LoggerHelpers.error(`Error generating module: ${error}`);
+        }
+        process.exit(1);
+    }
 }
 function generateBloc(moduleName, blocPath) {
     const blocFilePath = path.join(blocPath, `${moduleName}_bloc.dart`);