optikit 1.1.1 → 1.2.0

package/dist/utils/validationHelpers.js

@@ -0,0 +1,101 @@
+import fs from "fs";
+import path from "path";
+import { execCommand } from "./execHelpers.js";
+import { LoggerHelpers } from "./loggerHelpers.js";
+export { validateFlutterProject, validateFlutterSdk, validateIosProject, validateAndroidProject, checkFileExists, };
+/**
+ * Validates that the current directory is a Flutter project
+ * by checking for pubspec.yaml
+ */
+function validateFlutterProject() {
+    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 = false) {
+    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() {
+    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() {
+    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) {
+    return fs.existsSync(filePath);
+}

package/dist/utils/validators/validation.js

@@ -0,0 +1,101 @@
+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() {
+    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 = false) {
+    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() {
+    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() {
+    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) {
+    return fs.existsSync(filePath);
+}

package/dist/utils/versionHelpers.js

@@ -0,0 +1,80 @@
+import fs from "fs";
+import path from "path";
+export { parseVersion, incrementVersion, getCurrentVersion };
+/**
+ * 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) {
+    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, type, resetIosBuildNumber = false) {
+    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() {
+    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) {
+    return `${version.major}.${version.minor}.${version.patch}+${version.buildNumber}`;
+}
+/**
+ * Gets the next build number from current version
+ * @returns Next build number
+ */
+export function getNextBuildNumber() {
+    const current = getCurrentVersion();
+    return current.buildNumber + 1;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "optikit",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "description": "OptiKit CLI",
   "main": "src/cli.ts",
   "type": "module",

package/src/cli.ts

@@ -4,20 +4,29 @@ import chalk from "chalk";
 import boxen from "boxen";
 import yargs from "yargs/yargs";
 import { hideBin } from "yargs/helpers";
-import { generateModule } from "./commands/generateModule.js";
-import { cleanProject } from "./commands/cleanProject.js";
-import { cleanIosProject } from "./commands/cleanProjectIos.js";
-import { updateFlutterVersion } from "./commands/updateVersions.js";
+import { generateModule } from "./commands/project/generate.js";
+import { cleanProject } from "./commands/clean/flutter.js";
+import { cleanIosProject } from "./commands/clean/ios.js";
+import { updateFlutterVersion } from "./commands/version/update.js";
 import {
   buildFlutterApk,
   buildFlutterBundle,
   buildFlutterIos,
   buildFlutterIpa,
-} from "./commands/buildReleases.js";
+} from "./commands/build/releases.js";
 import { boxenOptions } from "./styles.js";
-import { openIos, openAndroid } from "./commands/openProject.js";
+import { openIos, openAndroid } from "./commands/project/open.js";
 import { createRequire } from "module";
-import { createVscodeSettings } from "./commands/setupVSCode.js";
+import { createVscodeSettings } from "./commands/project/setup.js";
+import { initializeProject } from "./commands/config/init.js";
+import { rollbackFiles, rollbackRestore } from "./commands/config/rollback.js";
+import {
+  bumpVersion,
+  bumpIosBuildOnly,
+  bumpAndroidBuildOnly,
+  showCurrentVersion
+} from "./commands/version/bump.js";
+import { listDevices, runApp, runAppInteractive } from "./commands/project/devices.js";
 const require = createRequire(import.meta.url);
 const packageInfo: { version: string } = require("../package.json");
 
@@ -191,5 +200,154 @@ const options = yargs(hideBin(process.argv))
       await createVscodeSettings();
     }
   )
+  .command(
+    "init",
+    "Initialize OptiKit configuration in the current project",
+    () => {},
+    async () => {
+      await initializeProject();
+    }
+  )
+  .command(
+    "rollback",
+    "List and restore files from OptiKit backups",
+    (yargs) => {
+      return yargs.option("restore", {
+        type: "number",
+        description: "Restore backup by index number",
+        demandOption: false,
+      });
+    },
+    async (argv) => {
+      const restoreIndex = argv.restore as number | undefined;
+      if (restoreIndex !== undefined) {
+        await rollbackRestore(restoreIndex);
+      } else {
+        await rollbackFiles();
+      }
+    }
+  )
+  .command(
+    "version",
+    "Show current version information",
+    () => {},
+    async () => {
+      await showCurrentVersion();
+    }
+  )
+  .command(
+    "version bump <type>",
+    "Bump version (major, minor, or patch)",
+    (yargs) => {
+      return yargs.positional("type", {
+        describe: "Version bump type (major, minor, patch)",
+        type: "string",
+        choices: ["major", "minor", "patch"],
+      });
+    },
+    async (argv) => {
+      const type = argv.type as 'major' | 'minor' | 'patch';
+      await bumpVersion(type);
+    }
+  )
+  .command(
+    "version bump-ios",
+    "Increment iOS build number only (for TestFlight)",
+    () => {},
+    async () => {
+      await bumpIosBuildOnly();
+    }
+  )
+  .command(
+    "version bump-android",
+    "Increment Android build number only",
+    () => {},
+    async () => {
+      await bumpAndroidBuildOnly();
+    }
+  )
+  .command(
+    "devices",
+    "List all connected devices",
+    (yargs) => {
+      return yargs.option("disable-fvm", {
+        type: "boolean",
+        default: false,
+        description: "Run without FVM (use --disable-fvm to enable)",
+      });
+    },
+    async (argv) => {
+      const useFvm = !argv.disableFvm;
+      await listDevices(useFvm);
+    }
+  )
+  .command(
+    "run",
+    "Run Flutter app on connected device",
+    (yargs) => {
+      return yargs
+        .option("device", {
+          alias: "d",
+          type: "string",
+          description: "Specific device ID to run on",
+        })
+        .option("release", {
+          alias: "r",
+          type: "boolean",
+          default: false,
+          description: "Run in release mode",
+        })
+        .option("flavor", {
+          alias: "f",
+          type: "string",
+          description: "Build flavor to use",
+        })
+        .option("disable-fvm", {
+          type: "boolean",
+          default: false,
+          description: "Run without FVM (use --disable-fvm to enable)",
+        });
+    },
+    async (argv) => {
+      const useFvm = !argv.disableFvm;
+      await runApp({
+        device: argv.device as string | undefined,
+        release: argv.release as boolean,
+        flavor: argv.flavor as string | undefined,
+        useFvm,
+      });
+    }
+  )
+  .command(
+    "run-select",
+    "Interactive device selection and run",
+    (yargs) => {
+      return yargs
+        .option("release", {
+          alias: "r",
+          type: "boolean",
+          default: false,
+          description: "Run in release mode",
+        })
+        .option("flavor", {
+          alias: "f",
+          type: "string",
+          description: "Build flavor to use",
+        })
+        .option("disable-fvm", {
+          type: "boolean",
+          default: false,
+          description: "Run without FVM (use --disable-fvm to enable)",
+        });
+    },
+    async (argv) => {
+      const useFvm = !argv.disableFvm;
+      await runAppInteractive({
+        release: argv.release as boolean,
+        flavor: argv.flavor as string | undefined,
+        useFvm,
+      });
+    }
+  )
   .version(version)
   .help(true).argv;

package/src/commands/build/releases.ts

@@ -0,0 +1,79 @@
+import { executeBuild } from "../../utils/helpers/build.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: boolean) {
+  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: boolean) {
+  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: boolean) {
+  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: boolean) {
+  await executeBuild(
+    {
+      type: "IPA",
+      command: "flutter build ipa",
+      flags: [...BUILD_CONFIGS.IPA.flags],
+      requireIos: true,
+    },
+    noFvm
+  );
+}

package/src/commands/clean/flutter.ts

@@ -0,0 +1,58 @@
+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: boolean) {
+  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/src/commands/{cleanProjectIos.ts → clean/ios.ts}

@@ -1,7 +1,8 @@
 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 { 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 };
 
@@ -61,21 +62,28 @@ async function ensureFlutterArtifactsExist() {
 }
 
 async function cleanIosProject(cleanCache: boolean, repoUpdate: boolean) {
-  try {
-    const xcodeProjPath = path.join(iosDirectory, "Runner.xcodeproj");
+  // Pre-flight validation
+  if (!validateFlutterProject()) {
+    process.exit(1);
+  }
 
-    if (!fs.existsSync(xcodeProjPath)) {
-      LoggerHelpers.error("No Xcode project found in the ios directory.");
-      return;
-    }
+  if (!validateIosProject()) {
+    process.exit(1);
+  }
 
+  try {
     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");
@@ -116,5 +124,6 @@ async function cleanIosProject(cleanCache: boolean, repoUpdate: boolean) {
     } else {
       LoggerHelpers.error(`Unknown error: ${JSON.stringify(error)}`);
     }
+    process.exit(1);
   }
 }