optikit 1.1.1 → 1.2.0

package/src/commands/config/init.ts

@@ -0,0 +1,63 @@
+import fs from "fs";
+import path from "path";
+import { LoggerHelpers } from "../../utils/services/logger.js";
+import { saveConfig } from "../../utils/services/config.js";
+
+export { initializeProject };
+
+/**
+ * Initializes OptiKit in the current project
+ * Creates .optikitrc configuration file with defaults
+ */
+async function initializeProject(): Promise<void> {
+  try {
+    LoggerHelpers.info("Initializing OptiKit in this project...");
+
+    const configPath = path.join(process.cwd(), ".optikitrc.json");
+
+    // Check if config already exists
+    if (fs.existsSync(configPath)) {
+      LoggerHelpers.warning("OptiKit configuration already exists.");
+      LoggerHelpers.info("To reconfigure, delete .optikitrc.json and run init again.");
+      return;
+    }
+
+    // Create default configuration
+    const defaultConfig = {
+      backupRetentionCount: 5,
+      useFvmByDefault: false,
+      autoBackup: true,
+      verbose: false,
+    };
+
+    // Save configuration
+    const success = saveConfig(defaultConfig);
+
+    if (success) {
+      LoggerHelpers.success("OptiKit initialized successfully!");
+      console.log("\nDefault configuration:");
+      console.log(JSON.stringify(defaultConfig, null, 2));
+      console.log("\nYou can modify .optikitrc.json to customize these settings.\n");
+
+      // Create .gitignore entry for backups if .gitignore exists
+      const gitignorePath = path.join(process.cwd(), ".gitignore");
+      if (fs.existsSync(gitignorePath)) {
+        const gitignoreContent = fs.readFileSync(gitignorePath, "utf8");
+        if (!gitignoreContent.includes(".optikit-backup")) {
+          fs.appendFileSync(
+            gitignorePath,
+            "\n# OptiKit backup files\n.optikit-backup/\n"
+          );
+          LoggerHelpers.success("Added .optikit-backup/ to .gitignore");
+        }
+      }
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      LoggerHelpers.error(`Error initializing project: ${error.message}`);
+    } else {
+      LoggerHelpers.error(`Error initializing project: ${error}`);
+    }
+    process.exit(1);
+  }
+}

package/src/commands/config/rollback.ts

@@ -0,0 +1,200 @@
+import fs from "fs";
+import path from "path";
+import { LoggerHelpers } from "../../utils/services/logger.js";
+import { restoreBackup } from "../../utils/services/backup.js";
+import chalk from "chalk";
+
+export { rollbackFiles };
+
+/**
+ * Lists all available backups and allows restoration
+ */
+async function rollbackFiles(): Promise<void> {
+  try {
+    LoggerHelpers.info("Searching for OptiKit backups...");
+
+    const backups = findAllBackups(process.cwd());
+
+    if (backups.length === 0) {
+      LoggerHelpers.warning("No backups found in this project.");
+      LoggerHelpers.info("Backups are created automatically when files are modified.");
+      return;
+    }
+
+    console.log(chalk.bold(`\nFound ${backups.length} backup(s):\n`));
+
+    // Group backups by original file
+    const backupsByFile = new Map<string, Array<{
+      backupPath: string;
+      timestamp: Date;
+      size: number;
+    }>>();
+
+    for (const backup of backups) {
+      const originalFile = getOriginalFilePath(backup.backupPath);
+      if (!backupsByFile.has(originalFile)) {
+        backupsByFile.set(originalFile, []);
+      }
+      backupsByFile.get(originalFile)!.push(backup);
+    }
+
+    // Display backups grouped by file
+    let index = 1;
+    const backupList: Array<{
+      index: number;
+      originalPath: string;
+      backupPath: string;
+      timestamp: Date;
+    }> = [];
+
+    for (const [originalFile, fileBackups] of backupsByFile) {
+      console.log(chalk.cyan.bold(`\n${originalFile}`));
+
+      // Sort by timestamp (newest first)
+      fileBackups.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+
+      for (const backup of fileBackups) {
+        const timeAgo = getTimeAgo(backup.timestamp);
+        const sizeKB = (backup.size / 1024).toFixed(2);
+
+        console.log(
+          chalk.gray(`  [${index}]`),
+          chalk.white(backup.timestamp.toLocaleString()),
+          chalk.gray(`(${timeAgo}, ${sizeKB} KB)`)
+        );
+
+        backupList.push({
+          index,
+          originalPath: originalFile,
+          backupPath: backup.backupPath,
+          timestamp: backup.timestamp,
+        });
+
+        index++;
+      }
+    }
+
+    console.log(chalk.yellow("\n" + "=".repeat(60)));
+    console.log(chalk.gray("To restore a backup, run:"));
+    console.log(chalk.white("  optikit rollback --restore <number>"));
+    console.log(chalk.gray("\nExample:"));
+    console.log(chalk.white("  optikit rollback --restore 1"));
+    console.log(chalk.yellow("=".repeat(60) + "\n"));
+
+  } catch (error) {
+    if (error instanceof Error) {
+      LoggerHelpers.error(`Error listing backups: ${error.message}`);
+    } else {
+      LoggerHelpers.error(`Error listing backups: ${error}`);
+    }
+    process.exit(1);
+  }
+}
+
+/**
+ * Restores a specific backup by index
+ */
+export async function rollbackRestore(index: number): Promise<void> {
+  try {
+    const backups = findAllBackups(process.cwd());
+
+    if (index < 1 || index > backups.length) {
+      LoggerHelpers.error(`Invalid backup index: ${index}`);
+      LoggerHelpers.info(`Please choose a number between 1 and ${backups.length}`);
+      process.exit(1);
+    }
+
+    const backup = backups[index - 1];
+    const originalPath = getOriginalFilePath(backup.backupPath);
+
+    LoggerHelpers.info(`Restoring: ${originalPath}`);
+    LoggerHelpers.info(`From backup: ${backup.timestamp.toLocaleString()}`);
+
+    const success = restoreBackup(originalPath, backup.backupPath);
+
+    if (success) {
+      LoggerHelpers.success("Backup restored successfully!");
+    } else {
+      LoggerHelpers.error("Failed to restore backup.");
+      process.exit(1);
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      LoggerHelpers.error(`Error restoring backup: ${error.message}`);
+    } else {
+      LoggerHelpers.error(`Error restoring backup: ${error}`);
+    }
+    process.exit(1);
+  }
+}
+
+/**
+ * Recursively finds all backup files in a directory
+ */
+function findAllBackups(
+  dir: string
+): Array<{ backupPath: string; timestamp: Date; size: number }> {
+  const backups: Array<{ backupPath: string; timestamp: Date; size: number }> = [];
+
+  function searchDirectory(currentDir: string): void {
+    const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = path.join(currentDir, entry.name);
+
+      if (entry.isDirectory()) {
+        if (entry.name === ".optikit-backup") {
+          // Found a backup directory
+          const backupFiles = fs.readdirSync(fullPath);
+          for (const backupFile of backupFiles) {
+            const backupPath = path.join(fullPath, backupFile);
+            const stats = fs.statSync(backupPath);
+            backups.push({
+              backupPath,
+              timestamp: stats.mtime,
+              size: stats.size,
+            });
+          }
+        } else if (!entry.name.startsWith(".") && entry.name !== "node_modules") {
+          // Recursively search subdirectories
+          searchDirectory(fullPath);
+        }
+      }
+    }
+  }
+
+  searchDirectory(dir);
+  return backups;
+}
+
+/**
+ * Extracts the original file path from a backup path
+ */
+function getOriginalFilePath(backupPath: string): string {
+  const backupDir = path.dirname(backupPath);
+  const originalDir = path.dirname(backupDir);
+  const backupFileName = path.basename(backupPath);
+
+  // Remove timestamp from filename
+  // Format: filename_YYYY-MM-DDTHH-MM-SS-mmmZ.ext
+  const match = backupFileName.match(/^(.+)_\d{4}-\d{2}-\d{2}T[\d-]+Z(\.\w+)$/);
+
+  if (match) {
+    const [, baseName, extension] = match;
+    return path.join(originalDir, `${baseName}${extension}`);
+  }
+
+  return path.join(originalDir, backupFileName);
+}
+
+/**
+ * Gets human-readable time ago string
+ */
+function getTimeAgo(date: Date): string {
+  const seconds = Math.floor((new Date().getTime() - date.getTime()) / 1000);
+
+  if (seconds < 60) return `${seconds}s ago`;
+  if (seconds < 3600) return `${Math.floor(seconds / 60)}m ago`;
+  if (seconds < 86400) return `${Math.floor(seconds / 3600)}h ago`;
+  return `${Math.floor(seconds / 86400)}d ago`;
+}

package/src/commands/project/devices.ts

@@ -0,0 +1,246 @@
+import { exec } from "child_process";
+import { promisify } from "util";
+import { execCommand } from "../../utils/services/exec.js";
+import { LoggerHelpers } from "../../utils/services/logger.js";
+import { validateFlutterProject, validateFlutterSdk } from "../../utils/validators/validation.js";
+import chalk from "chalk";
+
+const execAsync = promisify(exec);
+
+export { listDevices, runApp, getDevicesList, runAppInteractive };
+
+/**
+ * Device information structure
+ */
+interface DeviceInfo {
+  id: string;
+  name: string;
+  platform: string;
+  isEmulator: boolean;
+};
+
+/**
+ * Gets a parsed list of devices
+ */
+async function getDevicesList(useFvm: boolean = false): Promise<DeviceInfo[]> {
+  const flutterCommand = useFvm ? "fvm flutter" : "flutter";
+
+  try {
+    const { stdout } = await execAsync(`${flutterCommand} devices --machine`);
+    const devices = JSON.parse(stdout) as Array<{
+      id: string;
+      name: string;
+      platform: string;
+      emulator: boolean;
+    }>;
+
+    return devices.map(device => ({
+      id: device.id,
+      name: device.name,
+      platform: device.platform,
+      isEmulator: device.emulator
+    }));
+  } catch (error) {
+    // Fallback to empty array if parsing fails
+    return [];
+  }
+}
+
+/**
+ * Lists all connected devices with numbered list
+ */
+async function listDevices(useFvm: boolean = false): Promise<void> {
+  // Pre-flight validation
+  if (!validateFlutterProject()) {
+    process.exit(1);
+  }
+
+  if (!(await validateFlutterSdk(!useFvm))) {
+    process.exit(1);
+  }
+
+  try {
+    LoggerHelpers.info("Fetching connected devices...\n");
+
+    const devices = await getDevicesList(useFvm);
+
+    if (devices.length === 0) {
+      LoggerHelpers.warning("No devices found.");
+      console.log(chalk.gray("\nMake sure you have:"));
+      console.log(chalk.gray("  - A device connected via USB"));
+      console.log(chalk.gray("  - An emulator/simulator running"));
+      console.log(chalk.gray("  - Chrome browser for web development\n"));
+      return;
+    }
+
+    console.log(chalk.bold("\n📱 Connected Devices:\n"));
+
+    devices.forEach((device, index) => {
+      const number = chalk.cyan(`[${index + 1}]`);
+      const name = chalk.white.bold(device.name);
+      const platform = chalk.gray(`(${device.platform})`);
+      const type = device.isEmulator ? chalk.yellow(" [Emulator]") : chalk.green(" [Physical]");
+      const id = chalk.gray(`ID: ${device.id}`);
+
+      console.log(`${number} ${name} ${platform}${type}`);
+      console.log(`    ${id}`);
+      console.log();
+    });
+
+    console.log(chalk.gray("═".repeat(60)));
+    console.log(chalk.gray("To run on a specific device:"));
+    console.log(chalk.white("  optikit run --device <device-id>"));
+    console.log(chalk.gray("\nOr use interactive selection:"));
+    console.log(chalk.white("  optikit run-select"));
+    console.log(chalk.gray("═".repeat(60) + "\n"));
+
+  } catch (error) {
+    if (error instanceof Error) {
+      LoggerHelpers.error(`Error listing devices: ${error.message}`);
+    } else {
+      LoggerHelpers.error(`Error listing devices: ${error}`);
+    }
+    process.exit(1);
+  }
+}
+
+/**
+ * Configuration for running the Flutter app
+ */
+interface RunConfig {
+  device?: string;
+  release?: boolean;
+  flavor?: string;
+  useFvm?: boolean;
+}
+
+/**
+ * Runs the Flutter app on a connected device
+ */
+async function runApp(config: RunConfig): Promise<void> {
+  // Pre-flight validation
+  if (!validateFlutterProject()) {
+    process.exit(1);
+  }
+
+  if (!(await validateFlutterSdk(!config.useFvm))) {
+    process.exit(1);
+  }
+
+  try {
+    const flutterCommand = config.useFvm ? "fvm flutter" : "flutter";
+
+    // Build the run command
+    let command = `${flutterCommand} run`;
+
+    // Add device flag if specified
+    if (config.device) {
+      command += ` --device-id ${config.device}`;
+      LoggerHelpers.info(`Running on device: ${config.device}`);
+    } else {
+      LoggerHelpers.info("Running on default device...");
+    }
+
+    // Add release flag if specified
+    if (config.release) {
+      command += " --release";
+      LoggerHelpers.info("Running in release mode");
+    }
+
+    // Add flavor flag if specified
+    if (config.flavor) {
+      command += ` --flavor ${config.flavor}`;
+      LoggerHelpers.info(`Running with flavor: ${config.flavor}`);
+    }
+
+    console.log(chalk.cyan("\nStarting Flutter app..."));
+    console.log(chalk.gray(`Command: ${command}\n`));
+
+    await execCommand(command);
+
+  } catch (error) {
+    if (error instanceof Error) {
+      LoggerHelpers.error(`Error running app: ${error.message}`);
+    } else {
+      LoggerHelpers.error(`Error running app: ${error}`);
+    }
+    process.exit(1);
+  }
+}
+
+/**
+ * Interactive device selection and run
+ */
+async function runAppInteractive(config: Omit<RunConfig, 'device'>): Promise<void> {
+  // Pre-flight validation
+  if (!validateFlutterProject()) {
+    process.exit(1);
+  }
+
+  if (!(await validateFlutterSdk(!config.useFvm))) {
+    process.exit(1);
+  }
+
+  try {
+    LoggerHelpers.info("Fetching connected devices...\n");
+
+    const devices = await getDevicesList(config.useFvm);
+
+    if (devices.length === 0) {
+      LoggerHelpers.error("No devices found. Please connect a device or start an emulator.");
+      process.exit(1);
+    }
+
+    // Show devices
+    console.log(chalk.bold("\n📱 Connected Devices:\n"));
+
+    devices.forEach((device, index) => {
+      const number = chalk.cyan.bold(`[${index + 1}]`);
+      const name = chalk.white.bold(device.name);
+      const platform = chalk.gray(`(${device.platform})`);
+      const type = device.isEmulator ? chalk.yellow(" [Emulator]") : chalk.green(" [Physical]");
+
+      console.log(`${number} ${name} ${platform}${type}`);
+    });
+
+    console.log(chalk.gray("\n" + "═".repeat(60)));
+    console.log(chalk.cyan("Enter device number to run on:"));
+    console.log(chalk.gray("═".repeat(60) + "\n"));
+
+    // Use readline for user input
+    const readline = require('readline');
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+
+    rl.question(chalk.yellow("Device number: "), async (answer: string) => {
+      rl.close();
+
+      const deviceIndex = parseInt(answer) - 1;
+
+      if (isNaN(deviceIndex) || deviceIndex < 0 || deviceIndex >= devices.length) {
+        LoggerHelpers.error(`Invalid device number. Please choose between 1 and ${devices.length}`);
+        process.exit(1);
+      }
+
+      const selectedDevice = devices[deviceIndex];
+
+      console.log(chalk.green(`\n✓ Selected: ${selectedDevice.name}\n`));
+
+      // Run on selected device
+      await runApp({
+        ...config,
+        device: selectedDevice.id
+      });
+    });
+
+  } catch (error) {
+    if (error instanceof Error) {
+      LoggerHelpers.error(`Error: ${error.message}`);
+    } else {
+      LoggerHelpers.error(`Error: ${error}`);
+    }
+    process.exit(1);
+  }
+}

package/src/commands/{generateModule.ts → project/generate.ts}

@@ -4,27 +4,57 @@ import {
   createDirectories,
   writeFile,
   getClassName,
-} from "../utils/fileHelpers.js";
-import { LoggerHelpers } from "../utils/loggerHelpers.js";
+} from "../../utils/helpers/file.js";
+import { LoggerHelpers } from "../../utils/services/logger.js";
 
 export { generateModule };
 
 function generateModule(moduleName: string) {
-  const modulePath = path.join("lib", "module", moduleName);
-  const directories = ["bloc", "event", "state", "screen", "import", "factory"];
-
-  createDirectories(modulePath, directories);
-
-  LoggerHelpers.info(`Creating module structure for ${moduleName}...`);
-
-  generateBloc(moduleName, path.join(modulePath, "bloc"));
-  generateEvent(moduleName, path.join(modulePath, "event"));
-  generateState(moduleName, path.join(modulePath, "state"));
-  generateScreen(moduleName, path.join(modulePath, "screen"));
-  generateImport(moduleName, path.join(modulePath, "import"));
-  generateStateFactory(moduleName, path.join(modulePath, "factory"));
-
-  LoggerHelpers.success(`Module ${moduleName} created with full structure.`);
+  try {
+    // Validate module name
+    if (!moduleName || moduleName.trim().length === 0) {
+      LoggerHelpers.error("Module name cannot be empty.");
+      process.exit(1);
+    }
+
+    // Validate module name format (only lowercase letters, numbers, and underscores)
+    const validNamePattern = /^[a-z0-9_]+$/;
+    if (!validNamePattern.test(moduleName)) {
+      LoggerHelpers.error(
+        "Module name must contain only lowercase letters, numbers, and underscores."
+      );
+      process.exit(1);
+    }
+
+    const modulePath = path.join("lib", "module", moduleName);
+    const directories = ["bloc", "event", "state", "screen", "import", "factory"];
+
+    // Check if module already exists
+    if (fs.existsSync(modulePath)) {
+      LoggerHelpers.warning(`Module ${moduleName} already exists at ${modulePath}`);
+      LoggerHelpers.info("Files will be overwritten...");
+    }
+
+    createDirectories(modulePath, directories);
+
+    LoggerHelpers.info(`Creating module structure for ${moduleName}...`);
+
+    generateBloc(moduleName, path.join(modulePath, "bloc"));
+    generateEvent(moduleName, path.join(modulePath, "event"));
+    generateState(moduleName, path.join(modulePath, "state"));
+    generateScreen(moduleName, path.join(modulePath, "screen"));
+    generateImport(moduleName, path.join(modulePath, "import"));
+    generateStateFactory(moduleName, path.join(modulePath, "factory"));
+
+    LoggerHelpers.success(`Module ${moduleName} created with full structure.`);
+  } catch (error) {
+    if (error instanceof Error) {
+      LoggerHelpers.error(`Error generating module: ${error.message}`);
+    } else {
+      LoggerHelpers.error(`Error generating module: ${error}`);
+    }
+    process.exit(1);
+  }
 }
 
 function generateBloc(moduleName: string, blocPath: string) {

package/src/commands/{openProject.ts → project/open.ts}

@@ -1,12 +1,22 @@
-import { LoggerHelpers } from "../utils/loggerHelpers.js"; 
-import { execCommand } from "../utils/execHelpers.js"; 
-import { platform } from "os"; 
+import { LoggerHelpers } from "../../utils/services/logger.js";
+import { execCommand } from "../../utils/services/exec.js";
+import { platform } from "os";
+import { validateFlutterProject, validateIosProject, validateAndroidProject } from "../../utils/validators/validation.js";
 
 export { openIos, openAndroid };
 
 async function openIos() {
   LoggerHelpers.info("Opening the iOS project in Xcode...");
 
+  // Pre-flight validation
+  if (!validateFlutterProject()) {
+    process.exit(1);
+  }
+
+  if (!validateIosProject()) {
+    process.exit(1);
+  }
+
   const command = "open ios/Runner.xcworkspace";
 
   try {
@@ -18,12 +28,22 @@ async function openIos() {
     } else {
       LoggerHelpers.error(`Error while opening Xcode: ${error}`);
     }
+    process.exit(1);
   }
 }
 
 async function openAndroid() {
     LoggerHelpers.info("Opening the Android project in Android Studio...");
 
+    // Pre-flight validation
+    if (!validateFlutterProject()) {
+      process.exit(1);
+    }
+
+    if (!validateAndroidProject()) {
+      process.exit(1);
+    }
+
     const osPlatform = platform();
     let command;
 
@@ -33,9 +53,9 @@ async function openAndroid() {
     } else if (osPlatform === "darwin") {
       command = "open -a 'Android Studio' android";
     } else {
-      command = "xdg-open android"; 
+      command = "xdg-open android";
     }
-  
+
     try {
       await execCommand(command);
       LoggerHelpers.success("Android Studio opened successfully.");
@@ -47,5 +67,6 @@ async function openAndroid() {
       } else {
         LoggerHelpers.error(`Error while opening Android Studio: ${error}`);
       }
+      process.exit(1);
     }
 }

package/src/commands/project/setup.ts

@@ -0,0 +1,50 @@
+import fs from "fs";
+import path from "path";
+import { LoggerHelpers } from "../../utils/services/logger.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(){
+  try {
+    const vscodeDir = path.join(process.cwd(), ".vscode");
+    const settingsPath = path.join(vscodeDir, "settings.json");
+
+    // Create the .vscode folder using Node.js fs (cross-platform)
+    if (!fs.existsSync(vscodeDir)) {
+      fs.mkdirSync(vscodeDir, { recursive: true });
+      LoggerHelpers.success("Created .vscode directory.");
+    } else {
+      LoggerHelpers.info(".vscode directory already exists.");
+    }
+
+    // Define the settings object
+    const settings = {
+      "dart.flutterSdkPath": ".fvm/flutter_sdk",
+      "editor.formatOnSave": true,
+      "dart.previewFlutterUiGuides": true,
+      "files.exclude": {
+        "**/.git": true,
+        "**/.DS_Store": true,
+        "**/node_modules": true,
+        "**/build": true
+      }
+    };
+
+    // Write settings.json using Node.js fs
+    fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), "utf8");
+    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}`);
+    }
+    process.exit(1);
+  }
+}