optikit 1.1.1 → 1.2.0

package/dist/commands/rollback.js

@@ -0,0 +1,161 @@
+import fs from "fs";
+import path from "path";
+import { LoggerHelpers } from "../utils/loggerHelpers.js";
+import { restoreBackup } from "../utils/backupHelpers.js";
+import chalk from "chalk";
+export { rollbackFiles };
+/**
+ * Lists all available backups and allows restoration
+ */
+async function rollbackFiles() {
+    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();
+        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 = [];
+        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) {
+    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) {
+    const backups = [];
+    function searchDirectory(currentDir) {
+        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) {
+    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) {
+    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/dist/commands/setupVSCode.js

@@ -1,4 +1,5 @@
-import { execCommand } from "../utils/execHelpers.js";
+import fs from "fs";
+import path from "path";
 import { LoggerHelpers } from "../utils/loggerHelpers.js";
 export { createVscodeSettings, };
 /**
@@ -7,26 +8,30 @@ export { createVscodeSettings, };
  */
 async function createVscodeSettings() {
     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);
+        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) {
@@ -36,5 +41,6 @@ EOF
         else {
             LoggerHelpers.error(`Error while creating VSCode settings: ${error}`);
         }
+        process.exit(1);
     }
 }

package/dist/commands/updateVersions.js

@@ -1,9 +1,15 @@
 import fs from "fs";
 import path from "path";
 import { LoggerHelpers } from "../utils/loggerHelpers.js";
+import { validateFlutterProject } from "../utils/validationHelpers.js";
+import { createBackup } from "../utils/backupHelpers.js";
 const currentDir = process.cwd();
 export { updateFlutterVersion };
 async function updateFlutterVersion(version, build, iosBuild) {
+    // Pre-flight validation
+    if (!validateFlutterProject()) {
+        process.exit(1);
+    }
     try {
         // Always update the version since it is required.
         LoggerHelpers.info(`Starting update for version ${version}...`);
@@ -29,7 +35,7 @@ async function updateFlutterVersion(version, build, iosBuild) {
     }
     catch (error) {
         LoggerHelpers.error(`Error while updating Flutter version and build: ${error instanceof Error ? error.message : String(error)}`);
-        throw error;
+        process.exit(1);
     }
 }
 async function updatePubspecVersionAndBuild(version, build) {
@@ -38,6 +44,8 @@ async function updatePubspecVersionAndBuild(version, build) {
         if (!fs.existsSync(pubspecPath)) {
             throw new Error(`pubspec.yaml not found at ${pubspecPath}`);
         }
+        // Create backup before modification
+        createBackup(pubspecPath);
         const pubspecContent = fs.readFileSync(pubspecPath, "utf8");
         const updatedPubspec = pubspecContent.replace(/version: \d+\.\d+\.\d+\+\d+/g, `version: ${version}+${build}`);
         fs.writeFileSync(pubspecPath, updatedPubspec);
@@ -55,6 +63,8 @@ async function updateIosVersionAndBuild(version, iosBuild) {
         if (!fs.existsSync(projectPbxProjPath)) {
             throw new Error(`project.pbxproj not found at ${projectPbxProjPath}`);
         }
+        // Create backup before modification
+        createBackup(projectPbxProjPath);
         let projectContent = fs.readFileSync(projectPbxProjPath, 'utf8');
         projectContent = projectContent
             .replace(/MARKETING_VERSION\s*=\s*[^;]+;/g, `MARKETING_VERSION = ${version};`)
@@ -65,6 +75,8 @@ async function updateIosVersionAndBuild(version, iosBuild) {
         if (!fs.existsSync(infoPlistPath)) {
             throw new Error(`Info.plist not found at ${infoPlistPath}`);
         }
+        // Create backup before modification
+        createBackup(infoPlistPath);
         const infoPlistContent = fs.readFileSync(infoPlistPath, "utf8");
         const updatedPlist = infoPlistContent
             .replace(/<key>CFBundleShortVersionString<\/key>\s*<string>\$\{MARKETING_VERSION\}<\/string>/, `<key>CFBundleShortVersionString</key><string>${version}</string>`)

package/dist/commands/version/bump.js

@@ -0,0 +1,161 @@
+import { validateFlutterProject } from "../../utils/validators/validation.js";
+import { LoggerHelpers } from "../../utils/services/logger.js";
+import { getCurrentVersion, incrementVersion, formatVersion } from "../../utils/helpers/version.js";
+import { updateFlutterVersion } from "./update.js";
+import chalk from "chalk";
+export { bumpVersion, bumpIosBuildOnly, bumpAndroidBuildOnly, showCurrentVersion };
+/**
+ * Bumps version with semantic versioning (major, minor, patch)
+ * Android build number increments with version
+ * iOS build number resets to 1 on version change
+ *
+ * @param type - Type of version bump (major, minor, patch)
+ */
+async function bumpVersion(type) {
+    // Pre-flight validation
+    if (!validateFlutterProject()) {
+        process.exit(1);
+    }
+    try {
+        const current = getCurrentVersion();
+        const newVersion = incrementVersion(current, type);
+        LoggerHelpers.info(`Current version: ${formatVersion(current)}`);
+        LoggerHelpers.info(`Bumping ${type} version...`);
+        console.log(chalk.cyan("\nVersion changes:"));
+        console.log(chalk.gray("  Old:"), chalk.white(formatVersion(current)));
+        console.log(chalk.gray("  New:"), chalk.green.bold(formatVersion(newVersion)));
+        console.log(chalk.cyan("\nBuild number strategy:"));
+        console.log(chalk.gray("  Android:"), chalk.white(`${current.buildNumber} → ${newVersion.buildNumber} (incremented)`));
+        console.log(chalk.gray("  iOS:"), chalk.white(`${current.buildNumber} → 1 (reset for new version)`));
+        console.log();
+        // Update with new version
+        // Android uses the incremented build number from version
+        // iOS gets reset to 1 for new version releases
+        await updateFlutterVersion(`${newVersion.major}.${newVersion.minor}.${newVersion.patch}`, newVersion.buildNumber.toString(), "1" // iOS always starts at 1 for new versions
+        );
+        LoggerHelpers.success(`Version bumped to ${formatVersion(newVersion)}`);
+        console.log(chalk.gray("\nAndroid build:"), chalk.white(newVersion.buildNumber));
+        console.log(chalk.gray("iOS build:"), chalk.white("1"));
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            LoggerHelpers.error(`Error bumping version: ${error.message}`);
+        }
+        else {
+            LoggerHelpers.error(`Error bumping version: ${error}`);
+        }
+        process.exit(1);
+    }
+}
+/**
+ * Increments ONLY iOS build number (for TestFlight builds)
+ * Keeps version and Android build number unchanged
+ * Perfect for uploading new iOS builds without changing app version
+ *
+ * Example: 1.0.2+45 (iOS: 45) → 1.0.2+45 (iOS: 46)
+ */
+async function bumpIosBuildOnly() {
+    // Pre-flight validation
+    if (!validateFlutterProject()) {
+        process.exit(1);
+    }
+    try {
+        const current = getCurrentVersion();
+        const currentVersionString = `${current.major}.${current.minor}.${current.patch}`;
+        // iOS build number increments from current Android build number
+        const nextIosBuild = current.buildNumber + 1;
+        LoggerHelpers.info(`Current version: ${formatVersion(current)}`);
+        LoggerHelpers.info("Incrementing iOS build number only (for TestFlight)...");
+        console.log(chalk.cyan("\nBuild number changes:"));
+        console.log(chalk.gray("  Version:"), chalk.white(`${currentVersionString} (unchanged)`));
+        console.log(chalk.gray("  Android:"), chalk.white(`${current.buildNumber} (unchanged)`));
+        console.log(chalk.gray("  iOS:"), chalk.white(`${current.buildNumber} → ${nextIosBuild}`), chalk.green("(incremented)"));
+        console.log();
+        // Update only iOS build number
+        await updateFlutterVersion(currentVersionString, "", // Empty string means don't update Android
+        nextIosBuild.toString());
+        LoggerHelpers.success(`iOS build number incremented to ${nextIosBuild}`);
+        console.log(chalk.gray("\nResult:"), chalk.white(`${currentVersionString}+${current.buildNumber} (iOS: ${nextIosBuild})`));
+        console.log(chalk.gray("Use this for:"), chalk.white("TestFlight uploads without version changes"));
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            LoggerHelpers.error(`Error incrementing iOS build: ${error.message}`);
+        }
+        else {
+            LoggerHelpers.error(`Error incrementing iOS build: ${error}`);
+        }
+        process.exit(1);
+    }
+}
+/**
+ * Increments ONLY Android build number
+ * Keeps version and iOS build number unchanged
+ */
+async function bumpAndroidBuildOnly() {
+    // Pre-flight validation
+    if (!validateFlutterProject()) {
+        process.exit(1);
+    }
+    try {
+        const current = getCurrentVersion();
+        const currentVersionString = `${current.major}.${current.minor}.${current.patch}`;
+        const nextAndroidBuild = current.buildNumber + 1;
+        LoggerHelpers.info(`Current version: ${formatVersion(current)}`);
+        LoggerHelpers.info("Incrementing Android build number only...");
+        console.log(chalk.cyan("\nBuild number changes:"));
+        console.log(chalk.gray("  Version:"), chalk.white(`${currentVersionString} (unchanged)`));
+        console.log(chalk.gray("  Android:"), chalk.white(`${current.buildNumber} → ${nextAndroidBuild}`), chalk.green("(incremented)"));
+        console.log(chalk.gray("  iOS:"), chalk.white("(unchanged)"));
+        console.log();
+        // Update only Android build number
+        await updateFlutterVersion(currentVersionString, nextAndroidBuild.toString(), "" // Empty string means don't update iOS
+        );
+        LoggerHelpers.success(`Android build number incremented to ${nextAndroidBuild}`);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            LoggerHelpers.error(`Error incrementing Android build: ${error.message}`);
+        }
+        else {
+            LoggerHelpers.error(`Error incrementing Android build: ${error}`);
+        }
+        process.exit(1);
+    }
+}
+/**
+ * Shows current version information
+ */
+async function showCurrentVersion() {
+    try {
+        const current = getCurrentVersion();
+        const versionString = formatVersion(current);
+        console.log(chalk.bold("\n📱 Current Version Information\n"));
+        console.log(chalk.cyan("Version:"), chalk.white.bold(versionString));
+        console.log(chalk.gray("  Major:"), chalk.white(current.major));
+        console.log(chalk.gray("  Minor:"), chalk.white(current.minor));
+        console.log(chalk.gray("  Patch:"), chalk.white(current.patch));
+        console.log(chalk.gray("  Build:"), chalk.white(current.buildNumber));
+        console.log();
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            LoggerHelpers.error(`Error reading version: ${error.message}`);
+        }
+        else {
+            LoggerHelpers.error(`Error reading version: ${error}`);
+        }
+        process.exit(1);
+    }
+}
+/**
+ * Helper to get next iOS build number
+ * In the future, this could read from Info.plist or project.pbxproj
+ * For now, we'll use a simple increment
+ */
+async function getNextIosBuildNumber() {
+    // TODO: Read actual iOS build number from Info.plist or project.pbxproj
+    // For now, we'll just increment based on timestamp or simple counter
+    const current = getCurrentVersion();
+    return current.buildNumber + 1;
+}

package/dist/commands/version/update.js

@@ -0,0 +1,91 @@
+import fs from "fs";
+import path from "path";
+import { LoggerHelpers } from "../../utils/services/logger.js";
+import { validateFlutterProject } from "../../utils/validators/validation.js";
+import { createBackup } from "../../utils/services/backup.js";
+const currentDir = process.cwd();
+export { updateFlutterVersion };
+async function updateFlutterVersion(version, build, iosBuild) {
+    // Pre-flight validation
+    if (!validateFlutterProject()) {
+        process.exit(1);
+    }
+    try {
+        // Always update the version since it is required.
+        LoggerHelpers.info(`Starting update for version ${version}...`);
+        // Update pubspec.yaml only if an Android build number is provided.
+        if (build.trim().length > 0) {
+            LoggerHelpers.info("Updating build number in pubspec.yaml...");
+            await updatePubspecVersionAndBuild(version, build);
+        }
+        else {
+            LoggerHelpers.info("Android build number not provided. Skipping pubspec.yaml update.");
+        }
+        // Update iOS settings only if an iOS build number is provided.
+        if (iosBuild.trim().length > 0) {
+            LoggerHelpers.info("Updating iOS version and build number...");
+            await updateIosVersionAndBuild(version, iosBuild);
+        }
+        else {
+            LoggerHelpers.info("iOS build number not provided. Skipping iOS update.");
+        }
+        LoggerHelpers.success(`Update complete. Version set to ${version}` +
+            (build.trim().length > 0 ? `, Android build set to ${build}` : "") +
+            (iosBuild.trim().length > 0 ? `, and iOS build set to ${iosBuild}` : ""));
+    }
+    catch (error) {
+        LoggerHelpers.error(`Error while updating Flutter version and build: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+    }
+}
+async function updatePubspecVersionAndBuild(version, build) {
+    try {
+        const pubspecPath = path.join(currentDir, "pubspec.yaml");
+        if (!fs.existsSync(pubspecPath)) {
+            throw new Error(`pubspec.yaml not found at ${pubspecPath}`);
+        }
+        // Create backup before modification
+        createBackup(pubspecPath);
+        const pubspecContent = fs.readFileSync(pubspecPath, "utf8");
+        const updatedPubspec = pubspecContent.replace(/version: \d+\.\d+\.\d+\+\d+/g, `version: ${version}+${build}`);
+        fs.writeFileSync(pubspecPath, updatedPubspec);
+        LoggerHelpers.success(`Updated pubspec.yaml with version ${version} and build ${build}`);
+    }
+    catch (error) {
+        LoggerHelpers.error(`Error while updating pubspec.yaml version and build: ${error instanceof Error ? error.message : String(error)}`);
+        throw error;
+    }
+}
+async function updateIosVersionAndBuild(version, iosBuild) {
+    try {
+        const currentDir = process.cwd();
+        const projectPbxProjPath = path.join(currentDir, "ios/Runner.xcodeproj/project.pbxproj");
+        if (!fs.existsSync(projectPbxProjPath)) {
+            throw new Error(`project.pbxproj not found at ${projectPbxProjPath}`);
+        }
+        // Create backup before modification
+        createBackup(projectPbxProjPath);
+        let projectContent = fs.readFileSync(projectPbxProjPath, 'utf8');
+        projectContent = projectContent
+            .replace(/MARKETING_VERSION\s*=\s*[^;]+;/g, `MARKETING_VERSION = ${version};`)
+            .replace(/CURRENT_PROJECT_VERSION\s*=\s*[^;]+;/g, `CURRENT_PROJECT_VERSION = ${iosBuild};`);
+        fs.writeFileSync(projectPbxProjPath, projectContent);
+        LoggerHelpers.success(`Updated MARKETING_VERSION to ${version} and CURRENT_PROJECT_VERSION to ${iosBuild}`);
+        const infoPlistPath = path.join(currentDir, "ios/Runner/Info.plist");
+        if (!fs.existsSync(infoPlistPath)) {
+            throw new Error(`Info.plist not found at ${infoPlistPath}`);
+        }
+        // Create backup before modification
+        createBackup(infoPlistPath);
+        const infoPlistContent = fs.readFileSync(infoPlistPath, "utf8");
+        const updatedPlist = infoPlistContent
+            .replace(/<key>CFBundleShortVersionString<\/key>\s*<string>\$\{MARKETING_VERSION\}<\/string>/, `<key>CFBundleShortVersionString</key><string>${version}</string>`)
+            .replace(/<key>CFBundleVersion<\/key>\s*<string>\$\{CURRENT_PROJECT_VERSION\}<\/string>/, `<key>CFBundleVersion</key><string>${iosBuild}</string>`);
+        fs.writeFileSync(infoPlistPath, updatedPlist);
+        LoggerHelpers.success("Updated Info.plist with the new version and iOS build.");
+    }
+    catch (error) {
+        LoggerHelpers.error(`Error while updating iOS version and build: ${error instanceof Error ? error.message : String(error)}`);
+        throw error;
+    }
+}