optikit 1.1.1 → 1.2.0

package/dist/utils/helpers/build.js

@@ -0,0 +1,55 @@
+import { execCommand } from "../services/exec.js";
+import { LoggerHelpers } from "../services/logger.js";
+import { validateFlutterProject, validateFlutterSdk, validateIosProject, validateAndroidProject } from "../validators/validation.js";
+export { executeBuild };
+/**
+ * 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, noFvm) {
+    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/dist/utils/helpers/dryRun.js

@@ -0,0 +1,103 @@
+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() {
+    return dryRunEnabled;
+}
+/**
+ * Set dry-run mode
+ */
+function setDryRunMode(enabled) {
+    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 {
+    operations = [];
+    /**
+     * Log a command that would be executed
+     */
+    logCommand(description, command, details) {
+        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, filePath, details) {
+        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, result, message) {
+        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() {
+        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() {
+        this.operations = [];
+    }
+}

package/dist/utils/helpers/file.js

@@ -0,0 +1,24 @@
+import fs from "fs";
+import path from "path";
+import { capitalize } from "./string.js";
+export { createDirectories, writeFile, getClassName };
+function createDirectories(modulePath, directories) {
+    directories.forEach((dir) => {
+        const dirPath = path.join(modulePath, dir);
+        if (!fs.existsSync(dirPath)) {
+            fs.mkdirSync(dirPath, { recursive: true });
+        }
+    });
+}
+function writeFile(filePath, content) {
+    fs.writeFileSync(filePath, content);
+}
+function getClassName(moduleName, type) {
+    // 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);
+    });
+    return className;
+}

package/dist/utils/helpers/string.js

@@ -0,0 +1,3 @@
+export function capitalize(string) {
+    return string.charAt(0).toUpperCase() + string.slice(1).toLowerCase();
+}

package/dist/utils/helpers/version.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/dist/utils/services/backup.js

@@ -0,0 +1,88 @@
+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) {
+    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, backupPath) {
+    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, keepCount = 5) {
+    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) {
+    const parsedPath = path.parse(filePath);
+    return path.join(parsedPath.dir, ".optikit-backup");
+}

package/dist/utils/services/command.js

@@ -0,0 +1,51 @@
+import { validateFlutterProject, validateFlutterSdk, validateIosProject, validateAndroidProject } from "../validators/validation.js";
+export { validateBuildEnvironment, getFlutterCommand };
+/**
+ * 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) {
+    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, useFvm) {
+    if (useFvm) {
+        // Replace "flutter" with "fvm flutter"
+        return baseCommand.replace(/^flutter\s/, "fvm flutter ");
+    }
+    return baseCommand;
+}

package/dist/utils/services/config.js

@@ -0,0 +1,80 @@
+import fs from "fs";
+import path from "path";
+import { LoggerHelpers } from "./logger.js";
+export { loadConfig, saveConfig, getConfigPath };
+/**
+ * Default configuration
+ */
+const DEFAULT_CONFIG = {
+    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() {
+    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() {
+    const configPath = getConfigPath();
+    if (!configPath) {
+        return { ...DEFAULT_CONFIG };
+    }
+    try {
+        const fileContent = fs.readFileSync(configPath, "utf8");
+        const userConfig = JSON.parse(fileContent);
+        // 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) {
+    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/dist/utils/services/exec.js

@@ -0,0 +1,132 @@
+import { exec, spawn } from "child_process";
+import { promisify } from "util";
+import path from "path";
+import { LoggerHelpers } from "./logger.js";
+export const iosDirectory = path.join(process.cwd(), "ios");
+const execAsync = promisify(exec);
+export function handleExecResult(err, stdout, stderr) {
+    if (err) {
+        LoggerHelpers.error(`Error: ${err.message}`);
+        return;
+    }
+    if (stderr) {
+        LoggerHelpers.warning(`stderr: ${stderr}`);
+    }
+    if (stdout) {
+        LoggerHelpers.success(`stdout: ${stdout}`);
+    }
+}
+export async function execCommand(command) {
+    return new Promise((resolve, reject) => {
+        const fullCommand = `${command}`;
+        const process = spawn(fullCommand, { shell: true });
+        let output = "";
+        let lastLogLine = "";
+        process.stdout.on("data", (data) => {
+            const dataString = data.toString().trim();
+            output += dataString;
+            if (dataString) {
+                if ((dataString.endsWith("ms") || dataString.endsWith("s")) &&
+                    lastLogLine) {
+                    lastLogLine += ` ${dataString}`;
+                }
+                else {
+                    if (lastLogLine) {
+                        LoggerHelpers.success(lastLogLine);
+                    }
+                    lastLogLine = dataString;
+                }
+            }
+        });
+        process.stderr.on("data", (data) => {
+            LoggerHelpers.error(data.toString());
+        });
+        process.on("close", (code) => {
+            if (lastLogLine) {
+                LoggerHelpers.success(lastLogLine);
+            }
+            if (code !== 0) {
+                reject(new Error(`Command failed with exit code ${code}`));
+            }
+            else {
+                resolve(output);
+            }
+        });
+        process.on("error", (err) => {
+            reject(new Error(`Failed to start subprocess: ${err.message}`));
+        });
+    });
+}
+export async function execInIos(command) {
+    return new Promise((resolve, reject) => {
+        const fullCommand = `cd "${iosDirectory}" && ${command}`;
+        const process = spawn(fullCommand, { shell: true, timeout: 600000 });
+        let output = "";
+        let lastLogLine = "";
+        process.stdout.on("data", (data) => {
+            const dataString = data.toString().trim();
+            output += dataString;
+            if (dataString) {
+                if ((dataString.endsWith("ms") || dataString.endsWith("s")) &&
+                    lastLogLine) {
+                    lastLogLine += ` ${dataString}`;
+                }
+                else {
+                    if (lastLogLine) {
+                        LoggerHelpers.success(lastLogLine);
+                    }
+                    lastLogLine = dataString;
+                }
+            }
+        });
+        process.stderr.on("data", (data) => {
+            LoggerHelpers.error(data.toString());
+        });
+        process.on("close", (code) => {
+            if (lastLogLine) {
+                LoggerHelpers.success(lastLogLine);
+            }
+            if (code !== 0) {
+                reject(new Error(`Command failed with exit code ${code}`));
+            }
+            else {
+                resolve(output);
+            }
+        });
+        process.on("error", (err) => {
+            reject(new Error(`Failed to start subprocess: ${err.message}`));
+        });
+    });
+}
+export async function execInIosWithRetry(command, retries = 3, delay = 5000) {
+    let attempts = 0;
+    let lastError;
+    while (attempts < retries) {
+        try {
+            const result = await execInIos(command);
+            return result;
+        }
+        catch (error) {
+            attempts++;
+            lastError = error;
+            if (error instanceof Error) {
+                LoggerHelpers.error(`Attempt ${attempts} failed. Error: ${error.message}`);
+            }
+            else {
+                LoggerHelpers.error(`Attempt ${attempts} failed. Unknown error: ${JSON.stringify(error)}`);
+            }
+            if (attempts >= retries) {
+                if (lastError instanceof Error) {
+                    LoggerHelpers.error(`Command failed after ${retries} attempts: ${lastError.message}`);
+                }
+                else {
+                    LoggerHelpers.error(`Command failed after ${retries} attempts: Unknown error`);
+                }
+                throw new Error(`Command failed after ${retries} attempts: ${lastError instanceof Error ? lastError.message : "Unknown error"}`);
+            }
+            LoggerHelpers.error(`Retrying in ${delay / 1000} seconds...`);
+            await new Promise(resolve => setTimeout(resolve, delay));
+        }
+    }
+    throw lastError;
+}

package/dist/utils/services/logger.js

@@ -0,0 +1,15 @@
+import chalk from "chalk";
+export class LoggerHelpers {
+    static success(message) {
+        console.log(chalk.green(message));
+    }
+    static error(message) {
+        console.log(chalk.red(message));
+    }
+    static warning(message) {
+        console.log(chalk.yellow(message));
+    }
+    static info(message) {
+        console.log(chalk.hex('#add8e6')(message));
+    }
+}