optikit 1.1.0 → 1.2.0

package/dist/commands/init.js

@@ -0,0 +1,54 @@
+import fs from "fs";
+import path from "path";
+import { LoggerHelpers } from "../utils/loggerHelpers.js";
+import { saveConfig } from "../utils/configHelpers.js";
+export { initializeProject };
+/**
+ * Initializes OptiKit in the current project
+ * Creates .optikitrc configuration file with defaults
+ */
+async function initializeProject() {
+    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/dist/commands/openProject.js

@@ -1,9 +1,17 @@
 import { LoggerHelpers } from "../utils/loggerHelpers.js";
 import { execCommand } from "../utils/execHelpers.js";
 import { platform } from "os";
+import { validateFlutterProject, validateIosProject, validateAndroidProject } from "../utils/validationHelpers.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 {
         await execCommand(command);
@@ -16,10 +24,18 @@ 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;
     if (osPlatform === "win32") {
@@ -42,5 +58,6 @@ async function openAndroid() {
         else {
             LoggerHelpers.error(`Error while opening Android Studio: ${error}`);
         }
+        process.exit(1);
     }
 }

package/dist/commands/project/devices.js

@@ -0,0 +1,188 @@
+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 };
+;
+/**
+ * Gets a parsed list of devices
+ */
+async function getDevicesList(useFvm = false) {
+    const flutterCommand = useFvm ? "fvm flutter" : "flutter";
+    try {
+        const { stdout } = await execAsync(`${flutterCommand} devices --machine`);
+        const devices = JSON.parse(stdout);
+        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 = false) {
+    // 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);
+    }
+}
+/**
+ * Runs the Flutter app on a connected device
+ */
+async function runApp(config) {
+    // 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) {
+    // 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) => {
+            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/dist/commands/project/generate.js

@@ -0,0 +1,143 @@
+import fs from "fs";
+import path from "path";
+import { createDirectories, writeFile, getClassName, } from "../../utils/helpers/file.js";
+import { LoggerHelpers } from "../../utils/services/logger.js";
+export { generateModule };
+function generateModule(moduleName) {
+    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, blocPath) {
+    const blocFilePath = path.join(blocPath, `${moduleName}_bloc.dart`);
+    const className = getClassName(moduleName, "bloc");
+    const template = `part of '../import/${moduleName}_import.dart';
+
+class ${className}Bloc extends BaseBloc {
+    ${className}Bloc() : super(
+    ${className}Factory(), 
+    initialState: ${className}InitialState(),
+    ) {}
+
+    @override
+    void onDispose() {}
+}
+  `;
+    writeFile(blocFilePath, template);
+    LoggerHelpers.success(`Bloc file ${moduleName}_bloc.dart created in ${blocPath}`);
+}
+function generateEvent(moduleName, eventPath) {
+    const eventFilePath = path.join(eventPath, `${moduleName}_event.dart`);
+    const className = getClassName(moduleName, "event");
+    const template = `part of '../import/${moduleName}_import.dart';
+
+class ${className}InitialEvent extends BaseEvent {}
+  `;
+    writeFile(eventFilePath, template);
+    LoggerHelpers.success(`Event file ${moduleName}_event.dart created in ${eventPath}`);
+}
+function generateState(moduleName, statePath) {
+    const stateFilePath = path.join(statePath, `${moduleName}_state.dart`);
+    const className = getClassName(moduleName, "state");
+    const template = `part of '../import/${moduleName}_import.dart';
+
+class ${className}InitialState extends RenderDataState {
+  ${className}InitialState() : super(null);
+}
+  `;
+    writeFile(stateFilePath, template);
+    LoggerHelpers.success(`State file ${moduleName}_state.dart created in ${statePath}`);
+}
+function generateScreen(moduleName, screenPath) {
+    const screenFilePath = path.join(screenPath, `${moduleName}_screen.dart`);
+    const className = getClassName(moduleName, "screen");
+    const template = `part of '../import/${moduleName}_import.dart';
+
+class ${className}Screen extends StatefulWidget {
+  final ${className}Bloc bloc;
+  const ${className}Screen({super.key, required this.bloc});
+
+  @override
+  _${className}ScreenState createState() => _${className}ScreenState(bloc);
+}
+
+class _${className}ScreenState extends BaseScreen<${className}Bloc, ${className}Screen, dynamic> {
+  _${className}ScreenState(super.bloc);
+
+  @override
+  Widget buildWidget(BuildContext context, RenderDataState state) {
+    return Container();
+  }
+  
+  @override
+  void listenToState(BuildContext context, BaseState state) {}
+}
+  `;
+    writeFile(screenFilePath, template);
+    LoggerHelpers.success(`Screen file ${moduleName}_screen.dart created in ${screenPath}`);
+}
+function generateImport(moduleName, importPath) {
+    const importFilePath = path.join(importPath, `${moduleName}_import.dart`);
+    const className = getClassName(moduleName, "import");
+    const template = `import 'package:flutter/material.dart';
+import 'package:opticore/opticore.dart';
+
+part '../bloc/${moduleName}_bloc.dart';
+part '../event/${moduleName}_event.dart';
+part '../screen/${moduleName}_screen.dart';
+part '../state/${moduleName}_state.dart';
+part '../factory/${moduleName}_factory.dart';
+  `;
+    writeFile(importFilePath, template);
+    LoggerHelpers.success(`Import file ${moduleName}_import.dart created in ${importPath}`);
+}
+function generateStateFactory(moduleName, factoryPath) {
+    const factoryFilePath = path.join(factoryPath, `${moduleName}_factory.dart`);
+    const className = getClassName(moduleName, "state_factory");
+    const template = `part of '../import/${moduleName}_import.dart';
+
+class ${className}Factory extends BaseFactory {
+  @override
+  BaseState getState<M>(M data) {
+    return DefaultState();
+  }
+}
+  `;
+    writeFile(factoryFilePath, template);
+    LoggerHelpers.success(`State Factory file ${moduleName}_factory.dart created in ${factoryPath}`);
+}

package/dist/commands/project/open.js

@@ -0,0 +1,63 @@
+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 {
+        await execCommand(command);
+        LoggerHelpers.success("Xcode opened successfully.");
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            LoggerHelpers.error(`Error while opening Xcode: ${error.message}`);
+        }
+        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;
+    if (osPlatform === "win32") {
+        command = "start android";
+    }
+    else if (osPlatform === "darwin") {
+        command = "open -a 'Android Studio' android";
+    }
+    else {
+        command = "xdg-open android";
+    }
+    try {
+        await execCommand(command);
+        LoggerHelpers.success("Android Studio opened successfully.");
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            LoggerHelpers.error(`Error while opening Android Studio: ${error.message}`);
+        }
+        else {
+            LoggerHelpers.error(`Error while opening Android Studio: ${error}`);
+        }
+        process.exit(1);
+    }
+}

package/dist/commands/project/setup.js

@@ -0,0 +1,46 @@
+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);
+    }
+}