optikit 1.1.1 → 1.2.1

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);

package/src/utils/helpers/version.ts

@@ -0,0 +1,109 @@
+import fs from "fs";
+import path from "path";
+import { LoggerHelpers } from "../services/logger.js";
+
+export { parseVersion, incrementVersion, getCurrentVersion, VersionInfo };
+
+/**
+ * Version information structure
+ */
+interface VersionInfo {
+  major: number;
+  minor: number;
+  patch: number;
+  buildNumber: number;
+}
+
+/**
+ * Parses a version string in format "X.Y.Z+B"
+ * @param versionString - Version string (e.g., "1.2.3+45")
+ * @returns Parsed version info
+ */
+function parseVersion(versionString: string): VersionInfo {
+  const match = versionString.match(/^(\d+)\.(\d+)\.(\d+)\+(\d+)$/);
+
+  if (!match) {
+    throw new Error(`Invalid version format: ${versionString}. Expected format: X.Y.Z+B (e.g., 1.2.3+45)`);
+  }
+
+  return {
+    major: parseInt(match[1], 10),
+    minor: parseInt(match[2], 10),
+    patch: parseInt(match[3], 10),
+    buildNumber: parseInt(match[4], 10),
+  };
+}
+
+/**
+ * Increments version based on type
+ * @param current - Current version info
+ * @param type - Type of increment (major, minor, patch)
+ * @param resetIosBuildNumber - Whether to reset iOS build number to 1
+ * @returns New version info
+ */
+function incrementVersion(
+  current: VersionInfo,
+  type: 'major' | 'minor' | 'patch',
+  resetIosBuildNumber: boolean = false
+): VersionInfo {
+  const newVersion = { ...current };
+
+  switch (type) {
+    case 'major':
+      newVersion.major += 1;
+      newVersion.minor = 0;
+      newVersion.patch = 0;
+      newVersion.buildNumber += 1;
+      break;
+    case 'minor':
+      newVersion.minor += 1;
+      newVersion.patch = 0;
+      newVersion.buildNumber += 1;
+      break;
+    case 'patch':
+      newVersion.patch += 1;
+      newVersion.buildNumber += 1;
+      break;
+  }
+
+  return newVersion;
+}
+
+/**
+ * Gets current version from pubspec.yaml
+ * @returns Current version info
+ */
+function getCurrentVersion(): VersionInfo {
+  const pubspecPath = path.join(process.cwd(), "pubspec.yaml");
+
+  if (!fs.existsSync(pubspecPath)) {
+    throw new Error("pubspec.yaml not found. Are you in a Flutter project?");
+  }
+
+  const pubspecContent = fs.readFileSync(pubspecPath, "utf8");
+  const versionMatch = pubspecContent.match(/version:\s*(\d+\.\d+\.\d+\+\d+)/);
+
+  if (!versionMatch) {
+    throw new Error("No version found in pubspec.yaml");
+  }
+
+  return parseVersion(versionMatch[1]);
+}
+
+/**
+ * Formats version info to string
+ * @param version - Version info
+ * @returns Formatted version string (e.g., "1.2.3+45")
+ */
+export function formatVersion(version: VersionInfo): string {
+  return `${version.major}.${version.minor}.${version.patch}+${version.buildNumber}`;
+}
+
+/**
+ * Gets the next build number from current version
+ * @returns Next build number
+ */
+export function getNextBuildNumber(): number {
+  const current = getCurrentVersion();
+  return current.buildNumber + 1;
+}

package/src/utils/services/backup.ts

@@ -0,0 +1,109 @@
+import fs from "fs";
+import path from "path";
+import { LoggerHelpers } from "./logger.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: string): string | null {
+  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: string, backupPath: string): boolean {
+  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: string, keepCount: number = 5): void {
+  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: string): string {
+  const parsedPath = path.parse(filePath);
+  return path.join(parsedPath.dir, ".optikit-backup");
+}

package/src/utils/services/command.ts

@@ -0,0 +1,76 @@
+import { validateFlutterProject, validateFlutterSdk, validateIosProject, validateAndroidProject } from "../validators/validation.js";
+
+export { validateBuildEnvironment, getFlutterCommand };
+
+/**
+ * Validation options for build environment
+ */
+interface ValidationOptions {
+  requireFlutterProject?: boolean;
+  requireFlutterSdk?: boolean;
+  requireIosProject?: boolean;
+  requireAndroidProject?: boolean;
+  useFvm?: boolean;
+}
+
+/**
+ * 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: ValidationOptions): boolean {
+  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: string, useFvm: boolean): string {
+  if (useFvm) {
+    // Replace "flutter" with "fvm flutter"
+    return baseCommand.replace(/^flutter\s/, "fvm flutter ");
+  }
+  return baseCommand;
+}

package/src/utils/services/config.ts

@@ -0,0 +1,106 @@
+import fs from "fs";
+import path from "path";
+import { LoggerHelpers } from "./logger.js";
+
+export { loadConfig, saveConfig, getConfigPath, OptiKitConfig };
+
+/**
+ * OptiKit configuration interface
+ */
+interface OptiKitConfig {
+  /** Backup retention count */
+  backupRetentionCount?: number;
+  /** Default FVM usage */
+  useFvmByDefault?: boolean;
+  /** Auto-create backups before destructive operations */
+  autoBackup?: boolean;
+  /** Verbose logging */
+  verbose?: boolean;
+}
+
+/**
+ * Default configuration
+ */
+const DEFAULT_CONFIG: OptiKitConfig = {
+  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(): string | null {
+  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(): OptiKitConfig {
+  const configPath = getConfigPath();
+
+  if (!configPath) {
+    return { ...DEFAULT_CONFIG };
+  }
+
+  try {
+    const fileContent = fs.readFileSync(configPath, "utf8");
+    const userConfig = JSON.parse(fileContent) as Partial<OptiKitConfig>;
+
+    // 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: OptiKitConfig): boolean {
+  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/src/utils/{execHelpers.ts → services/exec.ts}

@@ -1,7 +1,7 @@
 import { exec, spawn } from "child_process";
 import { promisify } from "util";
 import path from "path";
-import { LoggerHelpers } from "../utils/loggerHelpers.js";
+import { LoggerHelpers } from "./logger.js";
 
 export const iosDirectory = path.join(process.cwd(), "ios");