optikit 1.1.1 → 1.2.0

package/src/commands/version/bump.ts

@@ -0,0 +1,202 @@
+import { validateFlutterProject } from "../../utils/validators/validation.js";
+import { LoggerHelpers } from "../../utils/services/logger.js";
+import {
+  getCurrentVersion,
+  incrementVersion,
+  formatVersion,
+  getNextBuildNumber
+} from "../../utils/helpers/version.js";
+import { updateFlutterVersion } from "./update.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: 'major' | 'minor' | 'patch'
+): Promise<void> {
+  // 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(): Promise<void> {
+  // 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(): Promise<void> {
+  // 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(): Promise<void> {
+  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(): Promise<number> {
+  // 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/src/commands/{updateVersions.ts → version/update.ts}

@@ -1,7 +1,9 @@
 import fs from "fs";
 import path from "path";
-import { execInIos } from "../utils/execHelpers.js";
-import { LoggerHelpers } from "../utils/loggerHelpers.js";
+import { execInIos } from "../../utils/services/exec.js";
+import { LoggerHelpers } from "../../utils/services/logger.js";
+import { validateFlutterProject } from "../../utils/validators/validation.js";
+import { createBackup } from "../../utils/services/backup.js";
 
 const currentDir = process.cwd();
 
@@ -12,6 +14,11 @@ async function updateFlutterVersion(
   build: string,
   iosBuild: string
 ) {
+  // Pre-flight validation
+  if (!validateFlutterProject()) {
+    process.exit(1);
+  }
+
   try {
     // Always update the version since it is required.
     LoggerHelpers.info(`Starting update for version ${version}...`);
@@ -43,7 +50,7 @@ async function updateFlutterVersion(
         error instanceof Error ? error.message : String(error)
       }`
     );
-    throw error;
+    process.exit(1);
   }
 }
 
@@ -55,6 +62,9 @@ async function updatePubspecVersionAndBuild(version: string, build: string) {
       throw new Error(`pubspec.yaml not found at ${pubspecPath}`);
     }
 
+    // Create backup before modification
+    createBackup(pubspecPath);
+
     const pubspecContent = fs.readFileSync(pubspecPath, "utf8");
 
     const updatedPubspec = pubspecContent.replace(
@@ -80,13 +90,16 @@ async function updatePubspecVersionAndBuild(version: string, build: string) {
 async function updateIosVersionAndBuild(version: string, iosBuild: string) {
     try {
       const currentDir = process.cwd();
-  
+
       const projectPbxProjPath = path.join(currentDir, "ios/Runner.xcodeproj/project.pbxproj");
-  
+
       if (!fs.existsSync(projectPbxProjPath)) {
         throw new Error(`project.pbxproj not found at ${projectPbxProjPath}`);
       }
-  
+
+      // Create backup before modification
+      createBackup(projectPbxProjPath);
+
       let projectContent = fs.readFileSync(projectPbxProjPath, 'utf8');
   
       projectContent = projectContent
@@ -109,6 +122,9 @@ async function updateIosVersionAndBuild(version: string, iosBuild: string) {
         throw new Error(`Info.plist not found at ${infoPlistPath}`);
       }
 
+      // Create backup before modification
+      createBackup(infoPlistPath);
+
       const infoPlistContent = fs.readFileSync(infoPlistPath, "utf8");
 
       const updatedPlist = infoPlistContent

package/src/constants.ts

@@ -0,0 +1,144 @@
+/**
+ * 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"],
+  },
+} as const;
+
+// 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",
+} as const;
+
+// Backup configuration
+export const BACKUP_CONFIG = {
+  DIR_NAME: ".optikit-backup",
+  RETENTION_COUNT: 5,
+} as const;
+
+// Module generation
+export const MODULE_STRUCTURE = {
+  DIRECTORIES: ["bloc", "event", "state", "screen", "import", "factory"],
+  NAME_PATTERN: /^[a-z0-9_]+$/,
+} as const;
+
+// 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",
+} as const;
+
+// 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",
+} as const;
+
+// 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",
+} as const;
+
+// 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",
+  },
+} as const;
+
+// 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,
+  },
+} as const;
+
+// Retry configuration
+export const RETRY_CONFIG = {
+  DEFAULT_ATTEMPTS: 3,
+  DEFAULT_DELAY_MS: 10000,
+  IOS_TIMEOUT_MS: 600000,
+} as const;
+
+// Help URLs
+export const HELP_URLS = {
+  FLUTTER_INSTALL: "https://flutter.dev/docs/get-started/install",
+  FVM_INSTALL: "https://fvm.app/docs/getting_started/installation",
+} as const;
+
+// 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.",
+} as const;
+
+// 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.",
+} as const;

package/src/utils/helpers/build.ts

@@ -0,0 +1,80 @@
+import { execCommand } from "../services/exec.js";
+import { LoggerHelpers } from "../services/logger.js";
+import { validateFlutterProject, validateFlutterSdk, validateIosProject, validateAndroidProject } from "../validators/validation.js";
+
+export { executeBuild, BuildConfig };
+
+/**
+ * Build configuration
+ */
+interface BuildConfig {
+  /** Build type name (e.g., "APK", "Bundle", "iOS", "IPA") */
+  type: string;
+  /** Base Flutter command (e.g., "flutter build apk") */
+  command: string;
+  /** Additional build flags */
+  flags?: string[];
+  /** Whether to validate iOS project */
+  requireIos?: boolean;
+  /** Whether to validate Android project */
+  requireAndroid?: boolean;
+}
+
+/**
+ * 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: BuildConfig, noFvm: boolean): Promise<void> {
+  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/src/utils/helpers/dryRun.ts

@@ -0,0 +1,124 @@
+import { LoggerHelpers } from "../services/logger.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(): boolean {
+  return dryRunEnabled;
+}
+
+/**
+ * Set dry-run mode
+ */
+function setDryRunMode(enabled: boolean): void {
+  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 {
+  private operations: Array<{
+    type: string;
+    description: string;
+    command?: string;
+    details?: string;
+  }> = [];
+
+  /**
+   * Log a command that would be executed
+   */
+  logCommand(description: string, command: string, details?: string): void {
+    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: string, filePath: string, details?: string): void {
+    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: string, result: boolean, message?: string): void {
+    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(): void {
+    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(): void {
+    this.operations = [];
+  }
+}

package/src/utils/{fileHelpers.ts → helpers/file.ts}

@@ -1,6 +1,6 @@
 import fs from "fs";
 import path from "path";
-import { capitalize } from "./stringHelpers.js";
+import { capitalize } from "./string.js";
 
 export { createDirectories, writeFile, getClassName };
 
@@ -18,7 +18,8 @@ function writeFile(filePath: string, content: string) {
 }
 
 function getClassName(moduleName: string, type: string): string {
-  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);