optikit 1.1.1 → 1.2.0

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

package/src/utils/validators/validation.ts

@@ -0,0 +1,122 @@
+import fs from "fs";
+import path from "path";
+import { execCommand } from "../services/exec.js";
+import { LoggerHelpers } from "../services/logger.js";
+
+export {
+  validateFlutterProject,
+  validateFlutterSdk,
+  validateIosProject,
+  validateAndroidProject,
+  checkFileExists,
+};
+
+/**
+ * Validates that the current directory is a Flutter project
+ * by checking for pubspec.yaml
+ */
+function validateFlutterProject(): boolean {
+  const pubspecPath = path.join(process.cwd(), "pubspec.yaml");
+
+  if (!fs.existsSync(pubspecPath)) {
+    LoggerHelpers.error("Not a Flutter project: pubspec.yaml not found.");
+    LoggerHelpers.info("Please run this command from the root of a Flutter project.");
+    return false;
+  }
+
+  // Check if pubspec.yaml contains Flutter SDK
+  const pubspecContent = fs.readFileSync(pubspecPath, "utf8");
+  if (!pubspecContent.includes("flutter:")) {
+    LoggerHelpers.error("Not a Flutter project: pubspec.yaml does not reference Flutter SDK.");
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * Validates that Flutter SDK is available (either via FVM or globally)
+ */
+async function validateFlutterSdk(useFvm: boolean = false): Promise<boolean> {
+  try {
+    if (useFvm) {
+      // Check if FVM directory exists
+      const fvmPath = path.join(process.cwd(), ".fvm", "flutter_sdk");
+      if (!fs.existsSync(fvmPath)) {
+        LoggerHelpers.error("FVM Flutter SDK not found at .fvm/flutter_sdk");
+        LoggerHelpers.info("Run 'fvm install' or use --disable-fvm flag.");
+        return false;
+      }
+
+      // Check if fvm command is available
+      await execCommand("fvm --version");
+      return true;
+    } else {
+      // Check if global Flutter is available
+      await execCommand("flutter --version");
+      return true;
+    }
+  } catch (error) {
+    if (useFvm) {
+      LoggerHelpers.error("FVM not found. Please install FVM or use --disable-fvm flag.");
+      LoggerHelpers.info("Install FVM: https://fvm.app/docs/getting_started/installation");
+    } else {
+      LoggerHelpers.error("Flutter SDK not found.");
+      LoggerHelpers.info("Install Flutter: https://flutter.dev/docs/get-started/install");
+    }
+    return false;
+  }
+}
+
+/**
+ * Validates that the iOS project exists
+ */
+function validateIosProject(): boolean {
+  const iosPath = path.join(process.cwd(), "ios");
+
+  if (!fs.existsSync(iosPath)) {
+    LoggerHelpers.error("iOS project directory not found.");
+    LoggerHelpers.info("Run 'flutter create .' to add iOS support.");
+    return false;
+  }
+
+  const xcodeProjPath = path.join(iosPath, "Runner.xcodeproj");
+  const xcworkspacePath = path.join(iosPath, "Runner.xcworkspace");
+
+  if (!fs.existsSync(xcodeProjPath) && !fs.existsSync(xcworkspacePath)) {
+    LoggerHelpers.error("No Xcode project or workspace found in ios/ directory.");
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * Validates that the Android project exists
+ */
+function validateAndroidProject(): boolean {
+  const androidPath = path.join(process.cwd(), "android");
+
+  if (!fs.existsSync(androidPath)) {
+    LoggerHelpers.error("Android project directory not found.");
+    LoggerHelpers.info("Run 'flutter create .' to add Android support.");
+    return false;
+  }
+
+  const buildGradlePath = path.join(androidPath, "build.gradle");
+  const buildGradleKtsPath = path.join(androidPath, "build.gradle.kts");
+
+  if (!fs.existsSync(buildGradlePath) && !fs.existsSync(buildGradleKtsPath)) {
+    LoggerHelpers.error("No build.gradle found in android/ directory.");
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * Checks if a file exists at the given path
+ */
+function checkFileExists(filePath: string): boolean {
+  return fs.existsSync(filePath);
+}

package/src/commands/buildReleases.ts

@@ -1,102 +0,0 @@
-import chalk from "chalk";
-import { execCommand } from "../utils/execHelpers.js";
-import { LoggerHelpers } from "../utils/loggerHelpers.js";
-
-export {
-  buildFlutterApk,
-  buildFlutterBundle,
-  buildFlutterIos,
-  buildFlutterIpa,
-};
-
-async function buildFlutterApk(noFvm: boolean) {
-  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}`);
-    }
-  }
-}
-
-async function buildFlutterBundle(noFvm: boolean) {
-  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}`);
-    }
-  }
-}
-
-async function buildFlutterIos(noFvm: boolean) {
-  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}`);
-    }
-  }
-}
-
-async function buildFlutterIpa(noFvm: boolean) {
-  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}`);
-    }
-  }
-}

package/src/commands/cleanProject.ts

@@ -1,25 +0,0 @@
-import { execCommand } from "../utils/execHelpers.js";
-import { LoggerHelpers } from "../utils/loggerHelpers.js";
-
-export { cleanProject };
-
-async function cleanProject(noFvm: boolean) {
-  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";
-
-  try {
-    await execCommand(command);
-    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}`);
-    }
-  }
-}

package/src/commands/setupVSCode.ts

@@ -1,44 +0,0 @@
-import chalk from "chalk";
-import { execCommand } from "../utils/execHelpers.js";
-import { LoggerHelpers } from "../utils/loggerHelpers.js";
-
-export {
-  createVscodeSettings,
-};
-
-/**
- * Creates a .vscode directory (if it doesn't exist) and writes a settings.json file
- * with recommended Flutter configuration. The Flutter SDK path is set to ".fvm/flutter_sdk".
- */
-async function createVscodeSettings(): Promise<void> {
-  try {
-    // Create the .vscode folder (using -p ensures it won't error if it already exists)
-    await execCommand('mkdir -p .vscode');
-    LoggerHelpers.success("Created .vscode directory (if not already present).");
-
-    // Use a heredoc to write the settings.json file
-    const command = `
-cat << 'EOF' > .vscode/settings.json
-{
-  "dart.flutterSdkPath": ".fvm/flutter_sdk",
-  "editor.formatOnSave": true,
-  "dart.previewFlutterUiGuides": true,
-  "files.exclude": {
-    "**/.git": true,
-    "**/.DS_Store": true,
-    "**/node_modules": true,
-    "**/build": true
-  }
-}
-EOF
-`;
-    await execCommand(command);
-    LoggerHelpers.success("Created .vscode/settings.json with Flutter configuration.");
-  } catch (error) {
-    if (error instanceof Error) {
-      LoggerHelpers.error(`Error while creating VSCode settings: ${error.message}`);
-    } else {
-      LoggerHelpers.error(`Error while creating VSCode settings: ${error}`);
-    }
-  }
-}