optikit 1.2.5 → 1.3.0

package/src/commands/project/devices.ts

@@ -1,12 +1,9 @@
-import { exec } from "child_process";
-import { promisify } from "util";
-import { execCommand } from "../../utils/services/exec.js";
+import { execCommand, execCommandSilent } from "../../utils/services/exec.js";
 import { LoggerHelpers } from "../../utils/services/logger.js";
 import { validateFlutterProject, validateFlutterSdk } from "../../utils/validators/validation.js";
+import { handleCommandError } from "../../utils/helpers/error.js";
 import chalk from "chalk";
 
-const execAsync = promisify(exec);
-
 export { listDevices, runApp, getDevicesList, runAppInteractive };
 
 /**
@@ -26,7 +23,7 @@ async function getDevicesList(useFvm: boolean = false): Promise<DeviceInfo[]> {
   const flutterCommand = useFvm ? "fvm flutter" : "flutter";
 
   try {
-    const { stdout } = await execAsync(`${flutterCommand} devices --machine`);
+    const stdout = await execCommandSilent(`${flutterCommand} devices --machine`);
     const devices = JSON.parse(stdout) as Array<{
       id: string;
       name: string;
@@ -95,12 +92,7 @@ async function listDevices(useFvm: boolean = false): Promise<void> {
     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);
+    handleCommandError(error, "Error listing devices");
   }
 }
 
@@ -159,12 +151,7 @@ async function runApp(config: RunConfig): Promise<void> {
     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);
+    handleCommandError(error, "Error running app");
   }
 }
 
@@ -214,6 +201,11 @@ async function runAppInteractive(config: Omit<RunConfig, 'device'>): Promise<voi
       output: process.stdout
     });
 
+    rl.on('error', () => {
+      LoggerHelpers.error("Input error. Please try again.");
+      process.exit(1);
+    });
+
     rl.question(chalk.yellow("Device number: "), async (answer: string) => {
       rl.close();
 
@@ -236,11 +228,6 @@ async function runAppInteractive(config: Omit<RunConfig, 'device'>): Promise<voi
     });
 
   } catch (error) {
-    if (error instanceof Error) {
-      LoggerHelpers.error(`Error: ${error.message}`);
-    } else {
-      LoggerHelpers.error(`Error: ${error}`);
-    }
-    process.exit(1);
+    handleCommandError(error, "Error selecting device");
   }
 }

package/src/commands/project/doctor.ts

@@ -0,0 +1,81 @@
+import chalk from "chalk";
+import { execCommandSilent } from "../../utils/services/exec.js";
+import { validateFlutterProject, validateIosProject, validateAndroidProject } from "../../utils/validators/validation.js";
+import { getConfigPath } from "../../utils/services/config.js";
+import { HELP_URLS } from "../../constants.js";
+import { sectionHeader } from "../../styles.js";
+
+export { runDoctor };
+
+interface CheckResult {
+  name: string;
+  passed: boolean;
+  version?: string;
+  fix?: string;
+}
+
+async function checkCommand(
+  name: string,
+  command: string,
+  fix: string
+): Promise<CheckResult> {
+  try {
+    const output = await execCommandSilent(command);
+    const version = output.trim().split("\n")[0];
+    return { name, passed: true, version };
+  } catch {
+    return { name, passed: false, fix };
+  }
+}
+
+async function runDoctor(): Promise<void> {
+  sectionHeader("OptiKit Doctor");
+
+  const results: CheckResult[] = [];
+
+  // Tool checks (run in parallel)
+  const toolChecks = await Promise.all([
+    checkCommand("Flutter SDK", "flutter --version", `Install Flutter: ${HELP_URLS.FLUTTER_INSTALL}`),
+    checkCommand("FVM", "fvm --version", `Install FVM: ${HELP_URLS.FVM_INSTALL} (optional)`),
+    checkCommand("CocoaPods", "pod --version", "Install: gem install cocoapods"),
+    checkCommand("Xcode CLI Tools", "xcode-select -p", "Install: xcode-select --install"),
+  ]);
+  results.push(...toolChecks);
+
+  // Project checks
+  results.push(
+    { name: "Flutter project", passed: validateFlutterProject(true), fix: "Run from Flutter project root" },
+    { name: "iOS project", passed: validateIosProject(true), fix: "Run: flutter create ." },
+    { name: "Android project", passed: validateAndroidProject(true), fix: "Run: flutter create ." },
+  );
+
+  const configPath = getConfigPath();
+  results.push({
+    name: "OptiKit config",
+    passed: configPath !== null,
+    version: configPath ?? undefined,
+    fix: "Run: optikit init",
+  });
+
+  // Display results
+  console.log();
+  let passCount = 0;
+
+  for (const result of results) {
+    if (result.passed) {
+      passCount++;
+      const ver = result.version ? chalk.gray(` ${result.version}`) : "";
+      console.log(chalk.green("   ✔"), chalk.white(result.name) + ver);
+    } else {
+      console.log(chalk.red("   ✖"), chalk.white(result.name));
+      if (result.fix) {
+        console.log(chalk.gray("     └─"), chalk.yellow(result.fix));
+      }
+    }
+  }
+
+  const total = results.length;
+  const color = passCount === total ? chalk.green : passCount >= total - 2 ? chalk.yellow : chalk.red;
+  console.log(chalk.gray("\n  ─────────────────────────────────"));
+  console.log(color(`  ${passCount}/${total} checks passed\n`));
+}

package/src/commands/project/generate.ts

@@ -6,31 +6,30 @@ import {
   getClassName,
 } from "../../utils/helpers/file.js";
 import { LoggerHelpers } from "../../utils/services/logger.js";
+import { handleCommandError } from "../../utils/helpers/error.js";
+import { ERROR_MESSAGES, MODULE_STRUCTURE } from "../../constants.js";
 
-export { generateModule };
+export { generateModule, generateRepoModule, addRoute };
 
 function generateModule(moduleName: string) {
-  try {
-    // Validate module name
-    if (!moduleName || moduleName.trim().length === 0) {
-      LoggerHelpers.error("Module name cannot be empty.");
-      process.exit(1);
-    }
+  // Validate module name
+  if (!moduleName || moduleName.trim().length === 0) {
+    LoggerHelpers.error(ERROR_MESSAGES.MODULE_NAME_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);
-    }
+  if (!MODULE_STRUCTURE.NAME_PATTERN.test(moduleName)) {
+    LoggerHelpers.error(ERROR_MESSAGES.MODULE_NAME_INVALID);
+    process.exit(1);
+  }
 
-    const modulePath = path.join("lib", "module", moduleName);
-    const directories = ["bloc", "event", "state", "screen", "import", "factory"];
+  const modulePath = path.join("lib", "module", moduleName);
+  const isNew = !fs.existsSync(modulePath);
 
-    // Check if module already exists
-    if (fs.existsSync(modulePath)) {
+  try {
+    const directories = [...MODULE_STRUCTURE.DIRECTORIES];
+
+    if (!isNew) {
       LoggerHelpers.warning(`Module ${moduleName} already exists at ${modulePath}`);
       LoggerHelpers.info("Files will be overwritten...");
     }
@@ -45,29 +44,43 @@ function generateModule(moduleName: string) {
     generateScreen(moduleName, path.join(modulePath, "screen"));
     generateImport(moduleName, path.join(modulePath, "import"));
     generateStateFactory(moduleName, path.join(modulePath, "factory"));
+    generateRepo(moduleName, path.join(modulePath, "repo"));
 
     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}`);
+    // Clean up only if we created a new module directory
+    if (isNew) {
+      if (fs.existsSync(modulePath)) {
+        try {
+          fs.rmSync(modulePath, { recursive: true });
+          LoggerHelpers.warning("Cleaned up partial module files.");
+        } catch { /* ignore cleanup errors */ }
+      }
     }
-    process.exit(1);
+    handleCommandError(error, "Error generating module");
   }
 }
 
 function generateBloc(moduleName: string, blocPath: string) {
   const blocFilePath = path.join(blocPath, `${moduleName}_bloc.dart`);
-  const className = getClassName(moduleName, "bloc");
+  const className = getClassName(moduleName);
 
   const template = `part of '../import/${moduleName}_import.dart';
 
 class ${className}Bloc extends BaseBloc {
     ${className}Bloc() : super(
-    ${className}Factory(), 
+    ${className}Factory(),
     initialState: ${className}InitialState(),
-    ) {}
+    ) {
+      on<${className}InitialEvent>(_onInitialEvent);
+    }
+
+    Future<void> _onInitialEvent(
+      ${className}InitialEvent event,
+      Emitter<BaseState> emit,
+    ) async {
+      // Handle initial event
+    }
 
     @override
     void onDispose() {}
@@ -82,7 +95,7 @@ class ${className}Bloc extends BaseBloc {
 
 function generateEvent(moduleName: string, eventPath: string) {
   const eventFilePath = path.join(eventPath, `${moduleName}_event.dart`);
-  const className = getClassName(moduleName, "event");
+  const className = getClassName(moduleName);
 
   const template = `part of '../import/${moduleName}_import.dart';
 
@@ -97,7 +110,7 @@ class ${className}InitialEvent extends BaseEvent {}
 
 function generateState(moduleName: string, statePath: string) {
   const stateFilePath = path.join(statePath, `${moduleName}_state.dart`);
-  const className = getClassName(moduleName, "state");
+  const className = getClassName(moduleName);
 
   const template = `part of '../import/${moduleName}_import.dart';
 
@@ -114,7 +127,7 @@ class ${className}InitialState extends RenderDataState {
 
 function generateScreen(moduleName: string, screenPath: string) {
   const screenFilePath = path.join(screenPath, `${moduleName}_screen.dart`);
-  const className = getClassName(moduleName, "screen");
+  const className = getClassName(moduleName);
 
   const template = `part of '../import/${moduleName}_import.dart';
 
@@ -147,7 +160,7 @@ class _${className}ScreenState extends BaseScreen<${className}Bloc, ${className}
 
 function generateImport(moduleName: string, importPath: string) {
   const importFilePath = path.join(importPath, `${moduleName}_import.dart`);
-  const className = getClassName(moduleName, "import");
+  const className = getClassName(moduleName);
 
   const template = `import 'package:flutter/material.dart';
 import 'package:opticore/opticore.dart';
@@ -157,6 +170,7 @@ part '../event/${moduleName}_event.dart';
 part '../screen/${moduleName}_screen.dart';
 part '../state/${moduleName}_state.dart';
 part '../factory/${moduleName}_factory.dart';
+part '../repo/${moduleName}_repo.dart';
   `;
 
   writeFile(importFilePath, template);
@@ -170,7 +184,7 @@ function generateStateFactory(moduleName: string, factoryPath: string) {
     factoryPath,
     `${moduleName}_factory.dart`
   );
-  const className = getClassName(moduleName, "state_factory");
+  const className = getClassName(moduleName);
 
   const template = `part of '../import/${moduleName}_import.dart';
 
@@ -187,3 +201,168 @@ class ${className}Factory extends BaseFactory {
     `State Factory file ${moduleName}_factory.dart created in ${factoryPath}`
   );
 }
+
+function generateRepo(moduleName: string, repoPath: string) {
+  const repoFilePath = path.join(repoPath, `${moduleName}_repo.dart`);
+  const className = getClassName(moduleName);
+
+  const template = `part of '../import/${moduleName}_import.dart';
+
+class ${className}Repo extends BaseRepo {
+
+  Future<ApiResponse<Map<String, dynamic>?>> fetchData() async {
+    return await networkHelper.request<Map<String, dynamic>>(
+      '/${moduleName.replace(/_/g, '-')}',
+      (json) => json ?? {},
+    );
+  }
+}
+  `;
+
+  writeFile(repoFilePath, template);
+  LoggerHelpers.success(
+    `Repo file ${moduleName}_repo.dart created in ${repoPath}`
+  );
+}
+
+/**
+ * Generates a repository for an existing module.
+ * Creates repo directory, generates repo file, and appends part directive to import file.
+ */
+function generateRepoModule(moduleName: string) {
+  try {
+    // Validate module name
+    if (!moduleName || moduleName.trim().length === 0) {
+      LoggerHelpers.error(ERROR_MESSAGES.MODULE_NAME_EMPTY);
+      process.exit(1);
+    }
+
+    if (!MODULE_STRUCTURE.NAME_PATTERN.test(moduleName)) {
+      LoggerHelpers.error(ERROR_MESSAGES.MODULE_NAME_INVALID);
+      process.exit(1);
+    }
+
+    const modulePath = path.join("lib", "module", moduleName);
+
+    // Verify module exists
+    if (!fs.existsSync(modulePath)) {
+      LoggerHelpers.error(`Module ${moduleName} does not exist at ${modulePath}. Create it first with: optikit generate module ${moduleName}`);
+      process.exit(1);
+    }
+
+    // Create repo directory
+    const repoPath = path.join(modulePath, "repo");
+    if (!fs.existsSync(repoPath)) {
+      fs.mkdirSync(repoPath, { recursive: true });
+    }
+
+    LoggerHelpers.info(`Adding repository to module ${moduleName}...`);
+    generateRepo(moduleName, repoPath);
+
+    // Append part directive to import file if not already present
+    const importFilePath = path.join(modulePath, "import", `${moduleName}_import.dart`);
+    if (fs.existsSync(importFilePath)) {
+      const importContent = fs.readFileSync(importFilePath, "utf8");
+      const repoPartLine = `part '../repo/${moduleName}_repo.dart';`;
+
+      if (!importContent.includes(repoPartLine)) {
+        const updatedContent = importContent.trimEnd() + `\n${repoPartLine}\n`;
+        writeFile(importFilePath, updatedContent);
+        LoggerHelpers.success(`Added repo part directive to ${moduleName}_import.dart`);
+      } else {
+        LoggerHelpers.info("Repo part directive already exists in import file.");
+      }
+    } else {
+      LoggerHelpers.warning(`Import file not found at ${importFilePath}. Add the part directive manually.`);
+    }
+
+    LoggerHelpers.success(`Repository added to module ${moduleName}.`);
+  } catch (error) {
+    handleCommandError(error, "Error generating repo");
+  }
+}
+
+/**
+ * Adds a route entry for a module to the app_router.dart file.
+ * Looks for the OPTIKIT_ROUTE_ANCHOR comment and inserts above it.
+ */
+function addRoute(moduleName: string) {
+  try {
+    if (!moduleName || moduleName.trim().length === 0) {
+      LoggerHelpers.error(ERROR_MESSAGES.MODULE_NAME_EMPTY);
+      process.exit(1);
+    }
+
+    if (!MODULE_STRUCTURE.NAME_PATTERN.test(moduleName)) {
+      LoggerHelpers.error(ERROR_MESSAGES.MODULE_NAME_INVALID);
+      process.exit(1);
+    }
+
+    const routerPath = path.join("lib", "config", "app_router.dart");
+
+    if (!fs.existsSync(routerPath)) {
+      LoggerHelpers.error("app_router.dart not found at lib/config/app_router.dart");
+      LoggerHelpers.info("Run 'optikit init-app' first to scaffold the app structure.");
+      process.exit(1);
+    }
+
+    const className = getClassName(moduleName);
+    const routeName = moduleName.replace(/_/g, '-');
+    const anchor = "// === OPTIKIT_ROUTE_ANCHOR === (do not remove this line)";
+
+    const routerContent = fs.readFileSync(routerPath, "utf8");
+
+    // Check if route already exists
+    if (routerContent.includes(`'/${routeName}'`)) {
+      LoggerHelpers.warning(`Route '/${routeName}' already exists in app_router.dart`);
+      return;
+    }
+
+    if (!routerContent.includes(anchor)) {
+      LoggerHelpers.error("Route anchor not found in app_router.dart. Cannot insert route.");
+      LoggerHelpers.info("Ensure the file contains: " + anchor);
+      process.exit(1);
+    }
+
+    // Build the import path for the module
+    const importPath = `import '../module/${moduleName}/import/${moduleName}_import.dart';`;
+
+    // Build route case
+    const routeCase = `      case '/${routeName}':
+        return MaterialPageRoute(
+          builder: (_) => BlocProvider(
+            create: (_) => ${className}Bloc(),
+            child: ${className}Screen(bloc: ${className}Bloc()),
+          ),
+        );`;
+
+    // Insert route above anchor
+    const updatedRouter = routerContent.replace(
+      anchor,
+      `${routeCase}\n      ${anchor}`
+    );
+
+    // Add import if not already present
+    let finalContent = updatedRouter;
+    if (!finalContent.includes(importPath)) {
+      // Insert import after the last existing import line
+      const lastImportIndex = finalContent.lastIndexOf("import ");
+      if (lastImportIndex !== -1) {
+        const endOfImportLine = finalContent.indexOf("\n", lastImportIndex);
+        finalContent =
+          finalContent.slice(0, endOfImportLine + 1) +
+          importPath + "\n" +
+          finalContent.slice(endOfImportLine + 1);
+      }
+    }
+
+    writeFile(routerPath, finalContent);
+
+    LoggerHelpers.success(`Route '/${routeName}' added for module ${moduleName}`);
+    LoggerHelpers.info(`  Route: '/${routeName}'`);
+    LoggerHelpers.info(`  Screen: ${className}Screen`);
+    LoggerHelpers.info(`  BLoC: ${className}Bloc`);
+  } catch (error) {
+    handleCommandError(error, "Error adding route");
+  }
+}

package/src/commands/project/setup.ts

@@ -1,21 +1,23 @@
 import fs from "fs";
 import path from "path";
 import { LoggerHelpers } from "../../utils/services/logger.js";
+import { validateFlutterProject } from "../../utils/validators/validation.js";
+import { handleCommandError } from "../../utils/helpers/error.js";
+import { VSCODE_SETTINGS_TEMPLATE, PROJECT_PATHS } from "../../constants.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(){
+async function createVscodeSettings() {
+  if (!validateFlutterProject()) {
+    process.exit(1);
+  }
+
   try {
-    const vscodeDir = path.join(process.cwd(), ".vscode");
-    const settingsPath = path.join(vscodeDir, "settings.json");
+    const vscodeDir = path.join(process.cwd(), PROJECT_PATHS.VSCODE_DIR);
+    const settingsPath = path.join(process.cwd(), PROJECT_PATHS.VSCODE_SETTINGS);
 
-    // Create the .vscode folder using Node.js fs (cross-platform)
     if (!fs.existsSync(vscodeDir)) {
       fs.mkdirSync(vscodeDir, { recursive: true });
       LoggerHelpers.success("Created .vscode directory.");
@@ -23,28 +25,9 @@ async function createVscodeSettings(){
       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");
+    fs.writeFileSync(settingsPath, JSON.stringify(VSCODE_SETTINGS_TEMPLATE, 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);
+    handleCommandError(error, "Error creating VSCode settings");
   }
-} 
+}

package/src/commands/project/status.ts

@@ -0,0 +1,72 @@
+import fs from "fs";
+import path from "path";
+import chalk from "chalk";
+import { getCurrentVersion, formatVersion, getCurrentIosBuildNumber } from "../../utils/helpers/version.js";
+import { getConfigPath } from "../../utils/services/config.js";
+import { validateFlutterProject } from "../../utils/validators/validation.js";
+import { PROJECT_PATHS, BACKUP_CONFIG } from "../../constants.js";
+
+export { showStatus };
+
+async function showStatus(): Promise<void> {
+  console.log(chalk.bold("\nOptiKit Status"));
+  console.log(chalk.gray("─".repeat(45)));
+
+  // Version info
+  if (validateFlutterProject(true)) {
+    try {
+      const current = getCurrentVersion();
+      const iosBuild = getCurrentIosBuildNumber();
+      console.log(chalk.cyan("\n  Version:"), chalk.white.bold(formatVersion(current)));
+      console.log(chalk.gray("    Android Build:"), chalk.white(current.buildNumber));
+      console.log(chalk.gray("    iOS Build:"), chalk.white(iosBuild));
+    } catch {
+      console.log(chalk.yellow("\n  Version:"), chalk.gray("Unable to read"));
+    }
+  } else {
+    console.log(chalk.yellow("\n  Version:"), chalk.gray("Not a Flutter project"));
+  }
+
+  // FVM status
+  const fvmPath = path.join(process.cwd(), PROJECT_PATHS.FVM_FLUTTER_SDK);
+  const useFvm = fs.existsSync(fvmPath);
+  console.log(chalk.cyan("  Flutter:"), chalk.white(useFvm ? "FVM" : "Global SDK"));
+
+  // Backup count
+  const backupCount = countBackups(process.cwd());
+  console.log(chalk.cyan("  Backups:"), chalk.white(backupCount > 0 ? `${backupCount} file(s)` : "None"));
+
+  // Config
+  const configPath = getConfigPath();
+  console.log(chalk.cyan("  Config:"), chalk.white(configPath ?? "Not initialized (run: optikit init)"));
+
+  // Project structure
+  const hasIos = fs.existsSync(path.join(process.cwd(), PROJECT_PATHS.IOS_DIR));
+  const hasAndroid = fs.existsSync(path.join(process.cwd(), PROJECT_PATHS.ANDROID_DIR));
+  const platforms = [hasIos ? "iOS" : null, hasAndroid ? "Android" : null].filter(Boolean).join(", ");
+  console.log(chalk.cyan("  Platforms:"), chalk.white(platforms || "None detected"));
+
+  console.log(chalk.gray("\n" + "─".repeat(45) + "\n"));
+}
+
+function countBackups(dir: string): number {
+  let count = 0;
+
+  function search(currentDir: string): void {
+    try {
+      const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          if (entry.name === BACKUP_CONFIG.DIR_NAME) {
+            count += fs.readdirSync(path.join(currentDir, entry.name)).length;
+          } else if (!entry.name.startsWith(".") && entry.name !== "node_modules") {
+            search(path.join(currentDir, entry.name));
+          }
+        }
+      }
+    } catch { /* skip inaccessible dirs */ }
+  }
+
+  search(dir);
+  return count;
+}