optikit 1.1.1 → 1.2.0

package/dist/commands/version.js

@@ -0,0 +1,161 @@
+import { validateFlutterProject } from "../utils/validationHelpers.js";
+import { LoggerHelpers } from "../utils/loggerHelpers.js";
+import { getCurrentVersion, incrementVersion, formatVersion } from "../utils/versionHelpers.js";
+import { updateFlutterVersion } from "./updateVersions.js";
+import chalk from "chalk";
+export { bumpVersion, bumpIosBuildOnly, bumpAndroidBuildOnly, showCurrentVersion };
+/**
+ * Bumps version with semantic versioning (major, minor, patch)
+ * Android build number increments with version
+ * iOS build number resets to 1 on version change
+ *
+ * @param type - Type of version bump (major, minor, patch)
+ */
+async function bumpVersion(type) {
+    // Pre-flight validation
+    if (!validateFlutterProject()) {
+        process.exit(1);
+    }
+    try {
+        const current = getCurrentVersion();
+        const newVersion = incrementVersion(current, type);
+        LoggerHelpers.info(`Current version: ${formatVersion(current)}`);
+        LoggerHelpers.info(`Bumping ${type} version...`);
+        console.log(chalk.cyan("\nVersion changes:"));
+        console.log(chalk.gray("  Old:"), chalk.white(formatVersion(current)));
+        console.log(chalk.gray("  New:"), chalk.green.bold(formatVersion(newVersion)));
+        console.log(chalk.cyan("\nBuild number strategy:"));
+        console.log(chalk.gray("  Android:"), chalk.white(`${current.buildNumber} → ${newVersion.buildNumber} (incremented)`));
+        console.log(chalk.gray("  iOS:"), chalk.white(`${current.buildNumber} → 1 (reset for new version)`));
+        console.log();
+        // Update with new version
+        // Android uses the incremented build number from version
+        // iOS gets reset to 1 for new version releases
+        await updateFlutterVersion(`${newVersion.major}.${newVersion.minor}.${newVersion.patch}`, newVersion.buildNumber.toString(), "1" // iOS always starts at 1 for new versions
+        );
+        LoggerHelpers.success(`Version bumped to ${formatVersion(newVersion)}`);
+        console.log(chalk.gray("\nAndroid build:"), chalk.white(newVersion.buildNumber));
+        console.log(chalk.gray("iOS build:"), chalk.white("1"));
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            LoggerHelpers.error(`Error bumping version: ${error.message}`);
+        }
+        else {
+            LoggerHelpers.error(`Error bumping version: ${error}`);
+        }
+        process.exit(1);
+    }
+}
+/**
+ * Increments ONLY iOS build number (for TestFlight builds)
+ * Keeps version and Android build number unchanged
+ * Perfect for uploading new iOS builds without changing app version
+ *
+ * Example: 1.0.2+45 (iOS: 45) → 1.0.2+45 (iOS: 46)
+ */
+async function bumpIosBuildOnly() {
+    // Pre-flight validation
+    if (!validateFlutterProject()) {
+        process.exit(1);
+    }
+    try {
+        const current = getCurrentVersion();
+        const currentVersionString = `${current.major}.${current.minor}.${current.patch}`;
+        // iOS build number increments from current Android build number
+        const nextIosBuild = current.buildNumber + 1;
+        LoggerHelpers.info(`Current version: ${formatVersion(current)}`);
+        LoggerHelpers.info("Incrementing iOS build number only (for TestFlight)...");
+        console.log(chalk.cyan("\nBuild number changes:"));
+        console.log(chalk.gray("  Version:"), chalk.white(`${currentVersionString} (unchanged)`));
+        console.log(chalk.gray("  Android:"), chalk.white(`${current.buildNumber} (unchanged)`));
+        console.log(chalk.gray("  iOS:"), chalk.white(`${current.buildNumber} → ${nextIosBuild}`), chalk.green("(incremented)"));
+        console.log();
+        // Update only iOS build number
+        await updateFlutterVersion(currentVersionString, "", // Empty string means don't update Android
+        nextIosBuild.toString());
+        LoggerHelpers.success(`iOS build number incremented to ${nextIosBuild}`);
+        console.log(chalk.gray("\nResult:"), chalk.white(`${currentVersionString}+${current.buildNumber} (iOS: ${nextIosBuild})`));
+        console.log(chalk.gray("Use this for:"), chalk.white("TestFlight uploads without version changes"));
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            LoggerHelpers.error(`Error incrementing iOS build: ${error.message}`);
+        }
+        else {
+            LoggerHelpers.error(`Error incrementing iOS build: ${error}`);
+        }
+        process.exit(1);
+    }
+}
+/**
+ * Increments ONLY Android build number
+ * Keeps version and iOS build number unchanged
+ */
+async function bumpAndroidBuildOnly() {
+    // Pre-flight validation
+    if (!validateFlutterProject()) {
+        process.exit(1);
+    }
+    try {
+        const current = getCurrentVersion();
+        const currentVersionString = `${current.major}.${current.minor}.${current.patch}`;
+        const nextAndroidBuild = current.buildNumber + 1;
+        LoggerHelpers.info(`Current version: ${formatVersion(current)}`);
+        LoggerHelpers.info("Incrementing Android build number only...");
+        console.log(chalk.cyan("\nBuild number changes:"));
+        console.log(chalk.gray("  Version:"), chalk.white(`${currentVersionString} (unchanged)`));
+        console.log(chalk.gray("  Android:"), chalk.white(`${current.buildNumber} → ${nextAndroidBuild}`), chalk.green("(incremented)"));
+        console.log(chalk.gray("  iOS:"), chalk.white("(unchanged)"));
+        console.log();
+        // Update only Android build number
+        await updateFlutterVersion(currentVersionString, nextAndroidBuild.toString(), "" // Empty string means don't update iOS
+        );
+        LoggerHelpers.success(`Android build number incremented to ${nextAndroidBuild}`);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            LoggerHelpers.error(`Error incrementing Android build: ${error.message}`);
+        }
+        else {
+            LoggerHelpers.error(`Error incrementing Android build: ${error}`);
+        }
+        process.exit(1);
+    }
+}
+/**
+ * Shows current version information
+ */
+async function showCurrentVersion() {
+    try {
+        const current = getCurrentVersion();
+        const versionString = formatVersion(current);
+        console.log(chalk.bold("\n📱 Current Version Information\n"));
+        console.log(chalk.cyan("Version:"), chalk.white.bold(versionString));
+        console.log(chalk.gray("  Major:"), chalk.white(current.major));
+        console.log(chalk.gray("  Minor:"), chalk.white(current.minor));
+        console.log(chalk.gray("  Patch:"), chalk.white(current.patch));
+        console.log(chalk.gray("  Build:"), chalk.white(current.buildNumber));
+        console.log();
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            LoggerHelpers.error(`Error reading version: ${error.message}`);
+        }
+        else {
+            LoggerHelpers.error(`Error reading version: ${error}`);
+        }
+        process.exit(1);
+    }
+}
+/**
+ * Helper to get next iOS build number
+ * In the future, this could read from Info.plist or project.pbxproj
+ * For now, we'll use a simple increment
+ */
+async function getNextIosBuildNumber() {
+    // TODO: Read actual iOS build number from Info.plist or project.pbxproj
+    // For now, we'll just increment based on timestamp or simple counter
+    const current = getCurrentVersion();
+    return current.buildNumber + 1;
+}

package/dist/constants.js

@@ -0,0 +1,131 @@
+/**
+ * Application-wide constants
+ */
+// Build configurations
+export const BUILD_CONFIGS = {
+    APK: {
+        outputPath: "build/app/outputs/symbols",
+        flags: ["--release", "--obfuscate"],
+    },
+    BUNDLE: {
+        outputPath: "build/app/outputs/symbols",
+        flags: ["--release", "--obfuscate"],
+    },
+    IOS: {
+        flags: ["--release"],
+    },
+    IPA: {
+        flags: ["--release"],
+    },
+};
+// Project structure
+export const PROJECT_PATHS = {
+    PUBSPEC: "pubspec.yaml",
+    PUBSPEC_LOCK: "pubspec.lock",
+    IOS_DIR: "ios",
+    ANDROID_DIR: "android",
+    LIB_DIR: "lib",
+    MODULE_DIR: "lib/module",
+    IOS_RUNNER_PROJ: "ios/Runner.xcodeproj",
+    IOS_RUNNER_WORKSPACE: "ios/Runner.xcworkspace",
+    IOS_PROJECT_PBXPROJ: "ios/Runner.xcodeproj/project.pbxproj",
+    IOS_INFO_PLIST: "ios/Runner/Info.plist",
+    IOS_PODFILE_LOCK: "ios/Podfile.lock",
+    ANDROID_BUILD_GRADLE: "android/build.gradle",
+    ANDROID_BUILD_GRADLE_KTS: "android/build.gradle.kts",
+    FVM_FLUTTER_SDK: ".fvm/flutter_sdk",
+    VSCODE_DIR: ".vscode",
+    VSCODE_SETTINGS: ".vscode/settings.json",
+};
+// Backup configuration
+export const BACKUP_CONFIG = {
+    DIR_NAME: ".optikit-backup",
+    RETENTION_COUNT: 5,
+};
+// Module generation
+export const MODULE_STRUCTURE = {
+    DIRECTORIES: ["bloc", "event", "state", "screen", "import", "factory"],
+    NAME_PATTERN: /^[a-z0-9_]+$/,
+};
+// Flutter commands
+export const FLUTTER_COMMANDS = {
+    CLEAN: "flutter clean",
+    PUB_GET: "flutter pub get",
+    BUILD_APK: "flutter build apk",
+    BUILD_BUNDLE: "flutter build appbundle",
+    BUILD_IOS: "flutter build ios",
+    BUILD_IPA: "flutter build ipa",
+    PRECACHE_IOS: "flutter precache --ios",
+    VERSION: "flutter --version",
+};
+// FVM commands
+export const FVM_COMMANDS = {
+    CLEAN: "fvm flutter clean",
+    PUB_GET: "fvm flutter pub get",
+    BUILD_APK: "fvm flutter build apk",
+    BUILD_BUNDLE: "fvm flutter build appbundle",
+    BUILD_IOS: "fvm flutter build ios",
+    BUILD_IPA: "fvm flutter build ipa",
+    PRECACHE_IOS: "fvm flutter precache --ios",
+    VERSION: "fvm --version",
+};
+// iOS commands
+export const IOS_COMMANDS = {
+    POD_DEINTEGRATE: "pod deintegrate",
+    POD_INSTALL: "pod install",
+    POD_UPDATE: "pod update",
+    POD_REPO_UPDATE: "pod repo update",
+    POD_CACHE_CLEAN: "pod cache clean --all",
+};
+// IDE commands
+export const IDE_COMMANDS = {
+    XCODE: "open ios/Runner.xcworkspace",
+    ANDROID_STUDIO: {
+        DARWIN: "open -a 'Android Studio' android",
+        WIN32: "start android",
+        LINUX: "xdg-open android",
+    },
+};
+// VSCode settings template
+export const VSCODE_SETTINGS_TEMPLATE = {
+    "dart.flutterSdkPath": ".fvm/flutter_sdk",
+    "editor.formatOnSave": true,
+    "dart.previewFlutterUiGuides": true,
+    "files.exclude": {
+        "**/.git": true,
+        "**/.DS_Store": true,
+        "**/node_modules": true,
+        "**/build": true,
+    },
+};
+// Retry configuration
+export const RETRY_CONFIG = {
+    DEFAULT_ATTEMPTS: 3,
+    DEFAULT_DELAY_MS: 10000,
+    IOS_TIMEOUT_MS: 600000,
+};
+// Help URLs
+export const HELP_URLS = {
+    FLUTTER_INSTALL: "https://flutter.dev/docs/get-started/install",
+    FVM_INSTALL: "https://fvm.app/docs/getting_started/installation",
+};
+// Error messages
+export const ERROR_MESSAGES = {
+    NOT_FLUTTER_PROJECT: "Not a Flutter project: pubspec.yaml not found.",
+    NO_FLUTTER_REFERENCE: "Not a Flutter project: pubspec.yaml does not reference Flutter SDK.",
+    FVM_NOT_FOUND: "FVM Flutter SDK not found at .fvm/flutter_sdk",
+    FLUTTER_NOT_FOUND: "Flutter SDK not found.",
+    IOS_PROJECT_NOT_FOUND: "iOS project directory not found.",
+    ANDROID_PROJECT_NOT_FOUND: "Android project directory not found.",
+    NO_XCODE_PROJECT: "No Xcode project or workspace found in ios/ directory.",
+    NO_BUILD_GRADLE: "No build.gradle found in android/ directory.",
+    MODULE_NAME_EMPTY: "Module name cannot be empty.",
+    MODULE_NAME_INVALID: "Module name must contain only lowercase letters, numbers, and underscores.",
+};
+// Info messages
+export const INFO_MESSAGES = {
+    RUN_FROM_PROJECT_ROOT: "Please run this command from the root of a Flutter project.",
+    ADD_IOS_SUPPORT: "Run 'flutter create .' to add iOS support.",
+    ADD_ANDROID_SUPPORT: "Run 'flutter create .' to add Android support.",
+    INSTALL_FVM_OR_DISABLE: "Run 'fvm install' or use --disable-fvm flag.",
+};

package/dist/utils/backupHelpers.js

@@ -0,0 +1,88 @@
+import fs from "fs";
+import path from "path";
+import { LoggerHelpers } from "./loggerHelpers.js";
+export { createBackup, restoreBackup, cleanupBackups, getBackupPath };
+/**
+ * Creates a backup of a file with timestamp
+ * Returns the backup path if successful, null otherwise
+ */
+function createBackup(filePath) {
+    try {
+        if (!fs.existsSync(filePath)) {
+            LoggerHelpers.warning(`File does not exist, skipping backup: ${filePath}`);
+            return null;
+        }
+        const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+        const parsedPath = path.parse(filePath);
+        const backupPath = path.join(parsedPath.dir, `.optikit-backup`, `${parsedPath.name}_${timestamp}${parsedPath.ext}`);
+        // Create backup directory if it doesn't exist
+        const backupDir = path.dirname(backupPath);
+        if (!fs.existsSync(backupDir)) {
+            fs.mkdirSync(backupDir, { recursive: true });
+        }
+        // Copy file to backup location
+        fs.copyFileSync(filePath, backupPath);
+        LoggerHelpers.info(`Backup created: ${backupPath}`);
+        return backupPath;
+    }
+    catch (error) {
+        LoggerHelpers.error(`Failed to create backup: ${error instanceof Error ? error.message : error}`);
+        return null;
+    }
+}
+/**
+ * Restores a file from backup
+ */
+function restoreBackup(originalPath, backupPath) {
+    try {
+        if (!fs.existsSync(backupPath)) {
+            LoggerHelpers.error(`Backup file not found: ${backupPath}`);
+            return false;
+        }
+        fs.copyFileSync(backupPath, originalPath);
+        LoggerHelpers.success(`Restored from backup: ${originalPath}`);
+        return true;
+    }
+    catch (error) {
+        LoggerHelpers.error(`Failed to restore backup: ${error instanceof Error ? error.message : error}`);
+        return false;
+    }
+}
+/**
+ * Cleans up old backups (keeps only the most recent N backups)
+ */
+function cleanupBackups(directory, keepCount = 5) {
+    try {
+        const backupDir = path.join(directory, ".optikit-backup");
+        if (!fs.existsSync(backupDir)) {
+            return;
+        }
+        const files = fs.readdirSync(backupDir);
+        // Sort by modification time (newest first)
+        const sortedFiles = files
+            .map((file) => ({
+            name: file,
+            path: path.join(backupDir, file),
+            mtime: fs.statSync(path.join(backupDir, file)).mtime.getTime(),
+        }))
+            .sort((a, b) => b.mtime - a.mtime);
+        // Delete old backups beyond keepCount
+        if (sortedFiles.length > keepCount) {
+            const filesToDelete = sortedFiles.slice(keepCount);
+            filesToDelete.forEach((file) => {
+                fs.unlinkSync(file.path);
+                LoggerHelpers.info(`Cleaned up old backup: ${file.name}`);
+            });
+        }
+    }
+    catch (error) {
+        LoggerHelpers.warning(`Failed to cleanup backups: ${error instanceof Error ? error.message : error}`);
+    }
+}
+/**
+ * Gets the backup directory path for a given file
+ */
+function getBackupPath(filePath) {
+    const parsedPath = path.parse(filePath);
+    return path.join(parsedPath.dir, ".optikit-backup");
+}

package/dist/utils/buildHelpers.js

@@ -0,0 +1,55 @@
+import { execCommand } from "./execHelpers.js";
+import { LoggerHelpers } from "./loggerHelpers.js";
+import { validateFlutterProject, validateFlutterSdk, validateIosProject, validateAndroidProject } from "./validationHelpers.js";
+export { executeBuild };
+/**
+ * Executes a Flutter build with common validation and error handling
+ *
+ * @param config - Build configuration
+ * @param noFvm - Whether to disable FVM usage
+ *
+ * @example
+ * await executeBuild({
+ *   type: "APK",
+ *   command: "flutter build apk",
+ *   flags: ["--release", "--obfuscate", "--split-debug-info=build/app/outputs/symbols"],
+ *   requireAndroid: true
+ * }, false);
+ */
+async function executeBuild(config, noFvm) {
+    const { type, command, flags = [], requireIos = false, requireAndroid = false } = config;
+    LoggerHelpers.info(noFvm
+        ? `Building Flutter ${type} without FVM...`
+        : `Building Flutter ${type} with FVM...`);
+    // Pre-flight validation
+    if (!validateFlutterProject()) {
+        process.exit(1);
+    }
+    if (!(await validateFlutterSdk(!noFvm))) {
+        process.exit(1);
+    }
+    if (requireIos && !validateIosProject()) {
+        process.exit(1);
+    }
+    if (requireAndroid && !validateAndroidProject()) {
+        process.exit(1);
+    }
+    // Build the full command
+    const baseCommand = noFvm ? command : command.replace(/^flutter\s/, "fvm flutter ");
+    const fullCommand = flags.length > 0
+        ? `${baseCommand} ${flags.join(" ")}`
+        : baseCommand;
+    try {
+        await execCommand(fullCommand);
+        LoggerHelpers.success(`Flutter ${type} build successful.`);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            LoggerHelpers.error(`Error during ${type} build: ${error.message}`);
+        }
+        else {
+            LoggerHelpers.error(`Error during ${type} build: ${error}`);
+        }
+        process.exit(1);
+    }
+}

package/dist/utils/commandHelpers.js

@@ -0,0 +1,51 @@
+import { validateFlutterProject, validateFlutterSdk, validateIosProject, validateAndroidProject } from "./validationHelpers.js";
+export { validateBuildEnvironment, getFlutterCommand };
+/**
+ * Performs common validation checks for commands
+ * Exits with code 1 if any validation fails
+ *
+ * @param options - Validation options
+ * @returns true if all validations pass (won't return false, exits instead)
+ */
+function validateBuildEnvironment(options) {
+    const { requireFlutterProject = true, requireFlutterSdk = false, requireIosProject = false, requireAndroidProject = false, useFvm = false, } = options;
+    // Flutter project validation
+    if (requireFlutterProject && !validateFlutterProject()) {
+        process.exit(1);
+    }
+    // Flutter SDK validation (async)
+    if (requireFlutterSdk) {
+        validateFlutterSdk(useFvm).then((isValid) => {
+            if (!isValid) {
+                process.exit(1);
+            }
+        });
+    }
+    // iOS project validation
+    if (requireIosProject && !validateIosProject()) {
+        process.exit(1);
+    }
+    // Android project validation
+    if (requireAndroidProject && !validateAndroidProject()) {
+        process.exit(1);
+    }
+    return true;
+}
+/**
+ * Gets the appropriate Flutter command based on FVM usage
+ *
+ * @param baseCommand - The base Flutter command (e.g., "flutter clean")
+ * @param useFvm - Whether to use FVM
+ * @returns The command string with or without FVM prefix
+ *
+ * @example
+ * getFlutterCommand("flutter clean", true) // "fvm flutter clean"
+ * getFlutterCommand("flutter pub get", false) // "flutter pub get"
+ */
+function getFlutterCommand(baseCommand, useFvm) {
+    if (useFvm) {
+        // Replace "flutter" with "fvm flutter"
+        return baseCommand.replace(/^flutter\s/, "fvm flutter ");
+    }
+    return baseCommand;
+}

package/dist/utils/configHelpers.js

@@ -0,0 +1,80 @@
+import fs from "fs";
+import path from "path";
+import { LoggerHelpers } from "./loggerHelpers.js";
+export { loadConfig, saveConfig, getConfigPath };
+/**
+ * Default configuration
+ */
+const DEFAULT_CONFIG = {
+    backupRetentionCount: 5,
+    useFvmByDefault: false,
+    autoBackup: true,
+    verbose: false,
+};
+/**
+ * Gets the config file path
+ * Checks multiple locations in priority order:
+ * 1. .optikitrc in current directory
+ * 2. .optikitrc in home directory
+ *
+ * @returns Config file path or null if not found
+ */
+function getConfigPath() {
+    const cwd = process.cwd();
+    const home = process.env.HOME || process.env.USERPROFILE || "";
+    const possiblePaths = [
+        path.join(cwd, ".optikitrc"),
+        path.join(cwd, ".optikitrc.json"),
+        path.join(home, ".optikitrc"),
+        path.join(home, ".optikitrc.json"),
+    ];
+    for (const configPath of possiblePaths) {
+        if (fs.existsSync(configPath)) {
+            return configPath;
+        }
+    }
+    return null;
+}
+/**
+ * Loads configuration from .optikitrc file
+ * Falls back to default configuration if file doesn't exist
+ *
+ * @returns Merged configuration (defaults + user config)
+ */
+function loadConfig() {
+    const configPath = getConfigPath();
+    if (!configPath) {
+        return { ...DEFAULT_CONFIG };
+    }
+    try {
+        const fileContent = fs.readFileSync(configPath, "utf8");
+        const userConfig = JSON.parse(fileContent);
+        // Merge with defaults
+        return {
+            ...DEFAULT_CONFIG,
+            ...userConfig,
+        };
+    }
+    catch (error) {
+        LoggerHelpers.warning(`Failed to load config from ${configPath}, using defaults.`);
+        return { ...DEFAULT_CONFIG };
+    }
+}
+/**
+ * Saves configuration to .optikitrc file in current directory
+ *
+ * @param config - Configuration to save
+ * @returns true if successful, false otherwise
+ */
+function saveConfig(config) {
+    const configPath = path.join(process.cwd(), ".optikitrc.json");
+    try {
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf8");
+        LoggerHelpers.success(`Configuration saved to ${configPath}`);
+        return true;
+    }
+    catch (error) {
+        LoggerHelpers.error(`Failed to save config: ${error instanceof Error ? error.message : error}`);
+        return false;
+    }
+}

package/dist/utils/dryRunHelpers.js

@@ -0,0 +1,103 @@
+import { LoggerHelpers } from "./loggerHelpers.js";
+import chalk from "chalk";
+export { DryRunManager, isDryRunMode, setDryRunMode };
+/**
+ * Global dry-run state
+ */
+let dryRunEnabled = false;
+/**
+ * Check if dry-run mode is enabled
+ */
+function isDryRunMode() {
+    return dryRunEnabled;
+}
+/**
+ * Set dry-run mode
+ */
+function setDryRunMode(enabled) {
+    dryRunEnabled = enabled;
+    if (enabled) {
+        LoggerHelpers.info(chalk.yellow("🔍 DRY-RUN MODE ENABLED - No commands will be executed"));
+        console.log(chalk.gray("Commands will be displayed but not run\n"));
+    }
+}
+/**
+ * Dry-run manager for tracking and displaying operations
+ */
+class DryRunManager {
+    operations = [];
+    /**
+     * Log a command that would be executed
+     */
+    logCommand(description, command, details) {
+        if (!isDryRunMode())
+            return;
+        this.operations.push({
+            type: "command",
+            description,
+            command,
+            details,
+        });
+        console.log(chalk.cyan("→"), chalk.bold(description));
+        console.log(chalk.gray("  Command:"), chalk.white(command));
+        if (details) {
+            console.log(chalk.gray("  Details:"), details);
+        }
+        console.log();
+    }
+    /**
+     * Log a file operation that would be performed
+     */
+    logFileOperation(operation, filePath, details) {
+        if (!isDryRunMode())
+            return;
+        this.operations.push({
+            type: "file",
+            description: `${operation}: ${filePath}`,
+            details,
+        });
+        console.log(chalk.cyan("→"), chalk.bold(operation));
+        console.log(chalk.gray("  File:"), chalk.white(filePath));
+        if (details) {
+            console.log(chalk.gray("  Details:"), details);
+        }
+        console.log();
+    }
+    /**
+     * Log a validation check
+     */
+    logValidation(check, result, message) {
+        if (!isDryRunMode())
+            return;
+        const icon = result ? chalk.green("✓") : chalk.red("✗");
+        const status = result ? chalk.green("PASS") : chalk.red("FAIL");
+        console.log(icon, chalk.bold(check), status);
+        if (message) {
+            console.log(chalk.gray("  "), message);
+        }
+    }
+    /**
+     * Display summary of dry-run operations
+     */
+    displaySummary() {
+        if (!isDryRunMode() || this.operations.length === 0)
+            return;
+        console.log(chalk.yellow("\n" + "=".repeat(60)));
+        console.log(chalk.yellow.bold("DRY-RUN SUMMARY"));
+        console.log(chalk.yellow("=".repeat(60)));
+        const commands = this.operations.filter((op) => op.type === "command");
+        const files = this.operations.filter((op) => op.type === "file");
+        console.log(chalk.white(`\nTotal operations: ${this.operations.length}`));
+        console.log(chalk.white(`  Commands: ${commands.length}`));
+        console.log(chalk.white(`  File operations: ${files.length}`));
+        console.log(chalk.yellow("\n" + "=".repeat(60)));
+        console.log(chalk.gray("No actual changes were made to your system."));
+        console.log(chalk.gray("Run without --dry-run to execute these operations.\n"));
+    }
+    /**
+     * Reset the operations log
+     */
+    reset() {
+        this.operations = [];
+    }
+}

package/dist/utils/fileHelpers.js

@@ -14,7 +14,8 @@ function writeFile(filePath, content) {
     fs.writeFileSync(filePath, content);
 }
 function getClassName(moduleName, type) {
-    const defineItems = moduleName.replace(type, "").split("_");
+    // Split module name by underscores and capitalize each part
+    const defineItems = moduleName.split("_").filter(item => item.length > 0);
     let className = "";
     defineItems.forEach((item) => {
         className += capitalize(item);