appwrite-utils-cli 1.5.2 → 1.6.0

package/src/interactiveCLI.ts

@@ -1,7 +1,5 @@
 import inquirer from "inquirer";
 import { UtilsController } from "./utilsController.js";
-import { createEmptyCollection, setupDirsFiles } from "./utils/setupFiles.js";
-import { fetchAllDatabases } from "./databases/methods.js";
 import { fetchAllCollections } from "./collections/methods.js";
 import { listBuckets, createBucket } from "./storage/methods.js";
 import {
@@ -13,12 +11,7 @@ import {
   Query,
   Functions,
 } from "node-appwrite";
-import { getClient } from "./utils/getClientFromConfig.js";
-import type { TransferOptions } from "./migrations/transfer.js";
-import { ComprehensiveTransfer, type ComprehensiveTransferOptions } from "./migrations/comprehensiveTransfer.js";
 import {
-  AppwriteFunctionSchema,
-  parseAttribute,
   PermissionToAppwritePermission,
   RuntimeSchema,
   permissionSchema,
@@ -33,27 +26,29 @@ import { ulid } from "ulidx";
 import chalk from "chalk";
 import { DateTime } from "luxon";
 import {
-  createFunctionTemplate,
-  deleteFunction,
-  downloadLatestFunctionDeployment,
   getFunction,
+  downloadLatestFunctionDeployment,
   listFunctions,
-  listSpecifications,
 } from "./functions/methods.js";
-import { deployLocalFunction } from "./functions/deployments.js";
 import { join } from "node:path";
 import path from "path";
 import fs from "node:fs";
 import os from "node:os";
-import { SchemaGenerator } from "./shared/schemaGenerator.js";
-import { ConfirmationDialogs } from "./shared/confirmationDialogs.js";
 import { MessageFormatter } from "./shared/messageFormatter.js";
-import { migrateConfig } from "./utils/configMigration.js";
 import { findAppwriteConfig } from "./utils/loadConfigs.js";
-import { findYamlConfig, addFunctionToYamlConfig } from "./config/yamlConfig.js";
+import { findYamlConfig } from "./config/yamlConfig.js";
+
+// Import command modules
+import { configCommands } from "./cli/commands/configCommands.js";
+import { databaseCommands } from "./cli/commands/databaseCommands.js";
+import { functionCommands } from "./cli/commands/functionCommands.js";
+import { transferCommands } from "./cli/commands/transferCommands.js";
+import { schemaCommands } from "./cli/commands/schemaCommands.js";
 
 enum CHOICES {
   MIGRATE_CONFIG = "🔄 Migrate TypeScript config to YAML (.appwrite structure)",
+  VALIDATE_CONFIG = "✅ Validate configuration (collections/tables conflicts)",
+  MIGRATE_COLLECTIONS_TO_TABLES = "🔀 Migrate collections to tables format",
   CREATE_COLLECTION_CONFIG = "📄 Create collection config file",
   CREATE_FUNCTION = "⚡ Create a new function, from scratch or using a template",
   DEPLOY_FUNCTION = "🚀 Deploy function(s)",
@@ -113,75 +108,80 @@ export class InteractiveCLI {
 
       switch (action) {
         case CHOICES.MIGRATE_CONFIG:
-          await this.migrateTypeScriptConfig();
+          await configCommands.migrateTypeScriptConfig(this);
+          break;
+        case CHOICES.VALIDATE_CONFIG:
+          await configCommands.validateConfiguration(this);
+          break;
+        case CHOICES.MIGRATE_COLLECTIONS_TO_TABLES:
+          await configCommands.migrateCollectionsToTables(this);
           break;
         case CHOICES.CREATE_COLLECTION_CONFIG:
-          await this.createCollectionConfig();
+          await configCommands.createCollectionConfig(this);
           break;
         case CHOICES.CREATE_FUNCTION:
           await this.initControllerIfNeeded();
-          await this.createFunction();
+          await functionCommands.createFunction(this);
           break;
         case CHOICES.DEPLOY_FUNCTION:
           await this.initControllerIfNeeded();
-          await this.deployFunction();
+          await functionCommands.deployFunction(this);
           break;
         case CHOICES.DELETE_FUNCTION:
           await this.initControllerIfNeeded();
-          await this.deleteFunction();
+          await functionCommands.deleteFunction(this);
           break;
         case CHOICES.SETUP_DIRS_FILES:
-          await setupDirsFiles(false, this.currentDir);
+          await schemaCommands.setupDirsFiles(this, false);
           break;
         case CHOICES.SETUP_DIRS_FILES_WITH_EXAMPLE_DATA:
-          await setupDirsFiles(true, this.currentDir);
+          await schemaCommands.setupDirsFiles(this, true);
           break;
         case CHOICES.SYNCHRONIZE_CONFIGURATIONS:
           await this.initControllerIfNeeded();
-          await this.synchronizeConfigurations();
+          await databaseCommands.synchronizeConfigurations(this);
           break;
         case CHOICES.SYNC_DB:
           await this.initControllerIfNeeded();
-          await this.syncDb();
+          await databaseCommands.syncDb(this);
           break;
         case CHOICES.TRANSFER_DATA:
           await this.initControllerIfNeeded();
-          await this.transferData();
+          await transferCommands.transferData(this);
           break;
         case CHOICES.COMPREHENSIVE_TRANSFER:
-          await this.comprehensiveTransfer();
+          await transferCommands.comprehensiveTransfer(this);
           break;
         case CHOICES.BACKUP_DATABASE:
           await this.initControllerIfNeeded();
-          await this.backupDatabase();
+          await databaseCommands.backupDatabase(this);
           break;
         case CHOICES.WIPE_DATABASE:
           await this.initControllerIfNeeded();
-          await this.wipeDatabase();
+          await databaseCommands.wipeDatabase(this);
           break;
         case CHOICES.WIPE_COLLECTIONS:
           await this.initControllerIfNeeded();
-          await this.wipeCollections();
+          await databaseCommands.wipeCollections(this);
           break;
         case CHOICES.GENERATE_SCHEMAS:
           await this.initControllerIfNeeded();
-          await this.generateSchemas();
+          await schemaCommands.generateSchemas(this);
           break;
         case CHOICES.GENERATE_CONSTANTS:
           await this.initControllerIfNeeded();
-          await this.generateConstants();
+          await schemaCommands.generateConstants(this);
           break;
         case CHOICES.IMPORT_DATA:
           await this.initControllerIfNeeded();
-          await this.importData();
+          await schemaCommands.importData(this);
           break;
         case CHOICES.RELOAD_CONFIG:
-          await this.initControllerIfNeeded();
-          await this.reloadConfig();
+          await configCommands.reloadConfigWithSessionPreservation(this);
           break;
         case CHOICES.UPDATE_FUNCTION_SPEC:
           await this.initControllerIfNeeded();
-          await this.updateFunctionSpec();
+          await functionCommands.updateFunctionSpec(this);
           break;
         case CHOICES.EXIT:
           MessageFormatter.success("Goodbye!");
@@ -198,6 +198,26 @@ export class InteractiveCLI {
     if (!this.controller) {
       this.controller = new UtilsController(this.currentDir, directConfig);
       await this.controller.init();
+    } else {
+      // Extract session info from existing controller before reinitializing
+      const sessionInfo = this.controller.getSessionInfo();
+      if (sessionInfo.hasSession && directConfig) {
+        // Create enhanced directConfig with session preservation
+        const enhancedDirectConfig = {
+          ...directConfig,
+          sessionCookie: (this.controller as any).sessionCookie,
+          sessionMetadata: (this.controller as any).sessionMetadata
+        };
+
+        // Reinitialize with session preservation
+        this.controller = new UtilsController(this.currentDir, enhancedDirectConfig);
+        await this.controller.init();
+      } else if (directConfig) {
+        // Standard reinitialize without session
+        this.controller = new UtilsController(this.currentDir, directConfig);
+        await this.controller.init();
+      }
+      // If no directConfig provided, keep existing controller
     }
   }
 
@@ -220,11 +240,7 @@ export class InteractiveCLI {
           acc.push(db);
         }
         return acc;
-      }, [] as Models.Database[])
-      .filter((db) => {
-        const useMigrations = this.controller?.config?.useMigrations ?? true;
-        return useMigrations || db.name.toLowerCase() !== "migrations";
-      });
+      }, [] as Models.Database[]);
 
     const hasLocalAndRemote =
       allDatabases.some((db) =>
@@ -245,11 +261,7 @@ export class InteractiveCLI {
               : " (Remote)"
             : ""),
         value: db,
-      }))
-      .filter((db) => {
-        const useMigrations = this.controller?.config?.useMigrations ?? true;
-        return useMigrations || db.name.toLowerCase() !== "migrations";
-      });
+      }));
 
     const { selectedDatabases } = await inquirer.prompt([
       {
@@ -282,10 +294,9 @@ export class InteractiveCLI {
       Query.equal("name", database.name),
     ]);
     if (dbExists.total === 0) {
-      console.log(
-        chalk.red(
-          `Database "${database.name}" does not exist, using only local collection options`
-        )
+      MessageFormatter.warning(
+        `Database "${database.name}" does not exist, using only local collection/table options`,
+        { prefix: "Database" }
       );
       shouldFilterByDatabase = false;
     } else {
@@ -312,14 +323,27 @@ export class InteractiveCLI {
           ),
         ];
 
-    if (shouldFilterByDatabase) {
-      // Keep local entries that don't have databaseId (common in config),
-      // but still filter remote collections by selected database.
-      allCollections = allCollections.filter((c) => {
-        if (!c.databaseId) return true;
-        return c.databaseId === database.$id;
-      });
-    }
+    if (shouldFilterByDatabase) {
+      // Enhanced filtering for tables with optional databaseId
+      allCollections = allCollections.filter((c: any) => {
+        // For remote collections, they should match the selected database
+        if (remoteCollections.some((rc) => rc.name === c.name)) {
+          return c.databaseId === database.$id;
+        }
+
+        // For local collections/tables:
+        // - Collections without databaseId are kept (backward compatibility)
+        // - Tables with databaseId must match the selected database
+        // - Tables without databaseId are kept (fallback for misconfigured tables)
+        if (!c.databaseId) return true;
+        return c.databaseId === database.$id;
+      });
+    }
+
+    // Filter out system tables (those starting with underscore)
+    allCollections = allCollections.filter(
+      (collection) => !collection.$id.startsWith('_')
+    );
 
     const hasLocalAndRemote =
       allCollections.some((coll) =>
@@ -329,18 +353,60 @@ export class InteractiveCLI {
         (coll) => !configCollections.some((c) => c.name === coll.name)
       );
 
+    // Enhanced choice display with type indicators
     const choices = allCollections
-      .sort((a, b) => a.name.localeCompare(b.name))
-      .map((collection) => ({
-        name:
-          collection.name +
-          (hasLocalAndRemote
-            ? configCollections.some((c) => c.name === collection.name)
-              ? " (Local)"
-              : " (Remote)"
-            : ""),
-        value: collection,
-      }));
+      .sort((a, b) => {
+        // Sort by type first (collections before tables), then by name
+        const aIsTable = (a as any)._isFromTablesDir || false;
+        const bIsTable = (b as any)._isFromTablesDir || false;
+
+        if (aIsTable !== bIsTable) {
+          return aIsTable ? 1 : -1; // Collections first, then tables
+        }
+
+        return a.name.localeCompare(b.name);
+      })
+      .map((collection) => {
+        const localCollection = configCollections.find((c) => c.name === collection.name);
+        const isLocal = !!localCollection;
+        const isTable = localCollection?._isFromTablesDir || (collection as any)._isFromTablesDir || false;
+        const sourceFolder = localCollection?._sourceFolder || (collection as any)._sourceFolder || 'collections';
+
+        let typeIndicator = '';
+        let locationIndicator = '';
+
+        // Type indicator
+        if (isTable) {
+          typeIndicator = chalk.cyan('[Table]');
+        } else {
+          typeIndicator = chalk.green('[Collection]');
+        }
+
+        // Location indicator
+        if (hasLocalAndRemote) {
+          if (isLocal) {
+            locationIndicator = chalk.gray(`(Local/${sourceFolder})`);
+          } else {
+            locationIndicator = chalk.gray('(Remote)');
+          }
+        } else if (isLocal) {
+          locationIndicator = chalk.gray(`(${sourceFolder}/)`);
+        }
+
+        // Database indicator for tables with explicit databaseId
+        let dbIndicator = '';
+        if (isTable && collection.databaseId && shouldFilterByDatabase) {
+          const matchesCurrentDb = collection.databaseId === database.$id;
+          if (!matchesCurrentDb) {
+            dbIndicator = chalk.yellow(` [DB: ${collection.databaseId}]`);
+          }
+        }
+
+        return {
+          name: `${typeIndicator} ${collection.name} ${locationIndicator}${dbIndicator}`,
+          value: collection,
+        };
+      });
 
     const { selectedCollections } = await inquirer.prompt([
       {
@@ -349,13 +415,52 @@ export class InteractiveCLI {
         message: chalk.blue(message),
         choices,
         loop: true,
-        pageSize: 10,
+        pageSize: 15, // Increased page size to accommodate additional info
       },
     ]);
 
     return selectedCollections;
   }
 
+  /**
+   * Enhanced collection/table selection with better guidance for mixed scenarios
+   */
+  private async selectCollectionsAndTables(
+    database: Models.Database,
+    databasesClient: Databases,
+    message: string,
+    multiSelect = true,
+    preferLocal = false,
+    shouldFilterByDatabase = false
+  ): Promise<Models.Collection[]> {
+    const configCollections = this.getLocalCollections();
+    const collectionsCount = configCollections.filter(c => !c._isFromTablesDir).length;
+    const tablesCount = configCollections.filter(c => c._isFromTablesDir).length;
+
+    // Provide context about what's available
+    if (collectionsCount > 0 && tablesCount > 0) {
+      MessageFormatter.info(`\n📋 Available items for database "${database.name}":`, { prefix: "Collections" });
+      MessageFormatter.info(`   Collections: ${collectionsCount} (from collections/ folder)`, { prefix: "Collections" });
+      MessageFormatter.info(`   Tables: ${tablesCount} (from tables/ folder)`, { prefix: "Collections" });
+
+      if (shouldFilterByDatabase) {
+        const filteredTables = configCollections.filter(c =>
+          c._isFromTablesDir && (!c.databaseId || c.databaseId === database.$id)
+        ).length;
+        if (filteredTables !== tablesCount) {
+          MessageFormatter.warning(`   Note: ${filteredTables}/${tablesCount} tables match this database`, { prefix: "Collections" });
+        }
+      }
+      MessageFormatter.info('', { prefix: "Collections" });
+    } else if (collectionsCount > 0) {
+      MessageFormatter.info(`📁 ${collectionsCount} collections available from collections/ folder\n`, { prefix: "Collections" });
+    } else if (tablesCount > 0) {
+      MessageFormatter.info(`📊 ${tablesCount} tables available from tables/ folder\n`, { prefix: "Collections" });
+    }
+
+    return this.selectCollections(database, databasesClient, message, multiSelect, preferLocal, shouldFilterByDatabase);
+  }
+
   private getTemplateDefaults(template: string) {
     const defaults = {
       "typescript-node": {
@@ -364,6 +469,12 @@ export class InteractiveCLI {
         commands: "npm install && npm run build",
         specification: "s-0.5vcpu-512mb" as Specification,
       },
+      "hono-typescript": {
+        runtime: "node-21.0" as Runtime,
+        entrypoint: "src/index.ts",
+        commands: "npm install && npm run build",
+        specification: "s-0.5vcpu-512mb" as Specification,
+      },
       "uv": {
         runtime: "python-3.12" as Runtime,
         entrypoint: "src/index.py",
@@ -386,115 +497,6 @@ export class InteractiveCLI {
     };
   }
 
-  private async createFunction(): Promise<void> {
-    const { name } = await inquirer.prompt([
-      {
-        type: "input",
-        name: "name",
-        message: "Function name:",
-        validate: (input) => input.length > 0,
-      },
-    ]);
-
-    const { template } = await inquirer.prompt([
-      {
-        type: "list",
-        name: "template",
-        message: "Select a template:",
-        choices: [
-          { name: "TypeScript Node.js", value: "typescript-node" },
-          { name: "Python with UV", value: "uv" },
-          { name: "Count Documents in Collection", value: "count-docs-in-collection" },
-          { name: "None (Empty Function)", value: "none" },
-        ],
-      },
-    ]);
-
-    // Get template defaults
-    const templateDefaults = this.getTemplateDefaults(template);
-
-    const { runtime } = await inquirer.prompt([
-      {
-        type: "list",
-        name: "runtime",
-        message: "Select runtime:",
-        choices: Object.values(RuntimeSchema.Values),
-        default: templateDefaults.runtime,
-      },
-    ]);
-
-    const specifications = await listSpecifications(
-      this.controller!.appwriteServer!
-    );
-    const { specification } = await inquirer.prompt([
-      {
-        type: "list",
-        name: "specification",
-        message: "Select specification:",
-        choices: [
-          { name: "None", value: undefined },
-          ...specifications.specifications.map((s) => ({
-            name: s.slug,
-            value: s.slug,
-          })),
-        ],
-        default: templateDefaults.specification,
-      },
-    ]);
-
-    const functionConfig: AppwriteFunction = {
-      $id: ulid(),
-      name,
-      runtime,
-      events: [],
-      execute: ["any"],
-      enabled: true,
-      logging: true,
-      entrypoint: templateDefaults.entrypoint,
-      commands: templateDefaults.commands,
-      specification: specification || templateDefaults.specification,
-      scopes: [],
-      timeout: 15,
-      schedule: "",
-      installationId: "",
-      providerRepositoryId: "",
-      providerBranch: "",
-      providerSilentMode: false,
-      providerRootDirectory: "",
-      templateRepository: "",
-      templateOwner: "",
-      templateRootDirectory: "",
-    };
-
-    if (template !== "none") {
-      await createFunctionTemplate(
-        template as "typescript-node" | "uv" | "count-docs-in-collection",
-        name,
-        "./functions"
-      );
-    }
-
-    // Add to in-memory config
-    if (!this.controller!.config!.functions) {
-      this.controller!.config!.functions = [];
-    }
-    this.controller!.config!.functions.push(functionConfig);
-
-    // If using YAML config, also add to YAML file
-    const yamlConfigPath = findYamlConfig(this.currentDir);
-    if (yamlConfigPath) {
-      try {
-        await addFunctionToYamlConfig(yamlConfigPath, functionConfig);
-      } catch (error) {
-        MessageFormatter.warning(
-          `Function created but failed to update YAML config: ${error instanceof Error ? error.message : error}`,
-          { prefix: "Functions" }
-        );
-      }
-    }
-
-    MessageFormatter.success("Function created successfully!", { prefix: "Functions" });
-  }
 
   private async findFunctionInSubdirectories(
     basePaths: string[],
@@ -521,9 +523,7 @@ export class InteractiveCLI {
       try {
         const stats = await fs.promises.stat(path);
         if (stats.isDirectory()) {
-          console.log(
-            chalk.green(`Found function at common location: ${path}`)
-          );
+          MessageFormatter.success(`Found function at common location: ${path}`, { prefix: "Functions" });
           return path;
         }
       } catch (error) {
@@ -532,11 +532,7 @@ export class InteractiveCLI {
     }
 
     // If not found in common locations, do recursive search
-    console.log(
-      chalk.yellow(
-        "Function not found in common locations, searching subdirectories..."
-      )
-    );
+    MessageFormatter.info("Function not found in common locations, searching subdirectories...", { prefix: "Functions" });
 
     const queue = [...basePaths];
     const searched = new Set<string>();
@@ -574,7 +570,7 @@ export class InteractiveCLI {
             );
 
             if (hasMatch) {
-              console.log(chalk.green(`Found function at: ${fullPath}`));
+              MessageFormatter.success(`Found function at: ${fullPath}`, { prefix: "Functions" });
               return fullPath;
             }
 
@@ -582,220 +578,13 @@ export class InteractiveCLI {
           }
         }
       } catch (error) {
-        console.log(
-          chalk.yellow(`Error reading directory ${currentPath}:`, error)
-        );
+        MessageFormatter.warning(`Error reading directory ${currentPath}: ${error}`, { prefix: "Functions" });
       }
     }
 
     return null;
   }
 
-  private async deployFunction(): Promise<void> {
-    await this.initControllerIfNeeded();
-    if (!this.controller?.config) {
-      console.log(chalk.red("Failed to initialize controller or load config"));
-      return;
-    }
-
-    const functions = await this.selectFunctions(
-      "Select function(s) to deploy:",
-      true,
-      true
-    );
-
-    if (!functions?.length) {
-      console.log(chalk.red("No function selected"));
-      return;
-    }
-
-    for (const functionConfig of functions) {
-      if (!functionConfig) {
-        console.log(chalk.red("Invalid function configuration"));
-        return;
-      }
-
-      // Ensure functions array exists
-      if (!this.controller.config.functions) {
-        this.controller.config.functions = [];
-      }
-
-      const functionNameLower = functionConfig.name
-        .toLowerCase()
-        .replace(/\s+/g, "-");
-
-      // Debug logging
-      console.log(chalk.blue(`🔍 Function deployment debug:`));
-      console.log(chalk.gray(`  Function name: ${functionConfig.name}`));
-      console.log(chalk.gray(`  Function ID: ${functionConfig.$id}`));
-      console.log(chalk.gray(`  Config dirPath: ${functionConfig.dirPath || 'undefined'}`));
-      if (functionConfig.dirPath) {
-        const expandedPath = functionConfig.dirPath.startsWith('~/') 
-          ? functionConfig.dirPath.replace('~', os.homedir())
-          : functionConfig.dirPath;
-        console.log(chalk.gray(`  Expanded dirPath: ${expandedPath}`));
-      }
-      console.log(chalk.gray(`  Appwrite folder: ${this.controller.getAppwriteFolderPath()}`));
-      console.log(chalk.gray(`  Current working dir: ${process.cwd()}`));
-
-      // Helper function to expand tilde in paths
-      const expandTildePath = (path: string): string => {
-        if (path.startsWith('~/')) {
-          return path.replace('~', os.homedir());
-        }
-        return path;
-      };
-
-      // Check locations in priority order:
-      const priorityLocations = [
-        // 1. Config dirPath if specified (with tilde expansion)
-        functionConfig.dirPath ? expandTildePath(functionConfig.dirPath) : undefined,
-        // 2. Appwrite config folder/functions/name
-        join(
-          this.controller.getAppwriteFolderPath()!,
-          "functions",
-          functionNameLower
-        ),
-        // 3. Current working directory/functions/name
-        join(process.cwd(), "functions", functionNameLower),
-        // 4. Current working directory/name
-        join(process.cwd(), functionNameLower),
-      ].filter((val): val is string => val !== undefined); // Remove undefined entries (in case dirPath is undefined)
-
-      console.log(chalk.blue(`🔍 Priority locations to check:`));
-      priorityLocations.forEach((loc, i) => {
-        console.log(chalk.gray(`  ${i + 1}. ${loc}`));
-      });
-
-      let functionPath: string | null = null;
-
-      // Check each priority location
-      for (const location of priorityLocations) {
-        console.log(chalk.gray(`  Checking: ${location} - ${fs.existsSync(location) ? 'EXISTS' : 'NOT FOUND'}`));
-        if (fs.existsSync(location)) {
-          console.log(chalk.green(`✅ Found function at: ${location}`));
-          functionPath = location;
-          break;
-        }
-      }
-
-      // If not found in priority locations, do a broader search
-      if (!functionPath) {
-        console.log(
-          chalk.yellow(
-            `Function not found in primary locations, searching subdirectories...`
-          )
-        );
-
-        // Search in both appwrite config directory and current working directory
-        functionPath = await this.findFunctionInSubdirectories(
-          [this.controller.getAppwriteFolderPath()!, process.cwd()],
-          functionNameLower
-        );
-      }
-
-      if (!functionPath) {
-        const { shouldDownload } = await inquirer.prompt([
-          {
-            type: "confirm",
-            name: "shouldDownload",
-            message:
-              "Function not found locally. Would you like to download the latest deployment?",
-            default: false,
-          },
-        ]);
-
-        if (shouldDownload) {
-          try {
-            console.log(chalk.blue("Downloading latest deployment..."));
-            const { path: downloadedPath, function: remoteFunction } =
-              await downloadLatestFunctionDeployment(
-                this.controller.appwriteServer!,
-                functionConfig.$id,
-                join(this.controller.getAppwriteFolderPath()!, "functions")
-              );
-            console.log(
-              chalk.green(`✨ Function downloaded to ${downloadedPath}`)
-            );
-
-            functionPath = downloadedPath;
-            functionConfig.dirPath = downloadedPath;
-
-            const existingIndex = this.controller.config.functions.findIndex(
-              (f) => f?.$id === remoteFunction.$id
-            );
-
-            if (existingIndex >= 0) {
-              this.controller.config.functions[existingIndex].dirPath =
-                downloadedPath;
-            }
-
-            await this.controller.reloadConfig();
-          } catch (error) {
-            console.error(
-              chalk.red("Failed to download function deployment:"),
-              error
-            );
-            return;
-          }
-        } else {
-          console.log(
-            chalk.red(
-              `Function ${functionConfig.name} not found locally. Cannot deploy.`
-            )
-          );
-          return;
-        }
-      }
-
-      if (!this.controller.appwriteServer) {
-        console.log(chalk.red("Appwrite server not initialized"));
-        return;
-      }
-
-      try {
-        await deployLocalFunction(
-          this.controller.appwriteServer,
-          functionConfig.name,
-          {
-            ...functionConfig,
-            dirPath: functionPath,
-          },
-          functionPath
-        );
-        MessageFormatter.success("Function deployed successfully!", { prefix: "Functions" });
-      } catch (error) {
-        console.error(chalk.red("Failed to deploy function:"), error);
-      }
-    }
-  }
-
-  private async deleteFunction(): Promise<void> {
-    const functions = await this.selectFunctions(
-      "Select functions to delete:",
-      true,
-      false
-    );
-
-    if (!functions.length) {
-      console.log(chalk.red("No functions selected"));
-      return;
-    }
-
-    for (const func of functions) {
-      try {
-        await deleteFunction(this.controller!.appwriteServer!, func.$id);
-        console.log(
-          chalk.green(`✨ Function ${func.name} deleted successfully!`)
-        );
-      } catch (error) {
-        console.error(
-          chalk.red(`Failed to delete function ${func.name}:`),
-          error
-        );
-      }
-    }
-  }
 
   private async selectFunctions(
     message: string,
@@ -813,7 +602,7 @@ export class InteractiveCLI {
     const allFunctions = [
       ...localFunctions,
       ...remoteFunctions.functions.filter(
-        (rf) => !localFunctions.some((lf) => lf.name === rf.name)
+        (rf: any) => !localFunctions.some((lf) => lf.name === rf.name)
       ),
     ];
 
@@ -893,21 +682,6 @@ export class InteractiveCLI {
     return selectedBuckets;
   }
 
-  private async createCollectionConfig(): Promise<void> {
-    const { collectionName } = await inquirer.prompt([
-      {
-        type: "input",
-        name: "collectionName",
-        message: chalk.blue("Enter the name of the collection:"),
-        validate: (input) =>
-          input.trim() !== "" || "Collection name cannot be empty.",
-      },
-    ]);
-    console.log(
-      chalk.green(`Creating collection config file for '${collectionName}'...`)
-    );
-    createEmptyCollection(collectionName);
-  }
 
   private async configureBuckets(
     config: AppwriteConfig,
@@ -1146,907 +920,113 @@ export class InteractiveCLI {
     );
   }
 
-  private async syncDb(): Promise<void> {
-    console.log(chalk.blue("Pushing local configuration to Appwrite..."));
 
-    const databases = await this.selectDatabases(
-      this.getLocalDatabases(),
-      chalk.blue("Select local databases to push:"),
-      true
-    );
 
-    if (!databases.length) {
-      console.log(
-        chalk.yellow("No databases selected. Skipping database sync.")
-      );
-      return;
+  private getLocalCollections(): (Models.Collection & {
+    _isFromTablesDir?: boolean;
+    _sourceFolder?: string;
+    databaseId?: string;
+  })[] {
+    const configCollections = this.controller!.config?.collections || [];
+    // @ts-expect-error - appwrite invalid types
+    return configCollections.map((c) => ({
+      $id: c.$id || ulid(),
+      $createdAt: DateTime.now().toISO(),
+      $updatedAt: DateTime.now().toISO(),
+      name: c.name,
+      enabled: c.enabled || true,
+      documentSecurity: c.documentSecurity || false,
+      attributes: c.attributes || [],
+      indexes: c.indexes || [],
+      $permissions: PermissionToAppwritePermission(c.$permissions) || [],
+      databaseId: c.databaseId,
+      _isFromTablesDir: (c as any)._isFromTablesDir || false,
+      _sourceFolder: (c as any)._isFromTablesDir ? 'tables' : 'collections',
+    }));
+  }
+
+  private getLocalDatabases(): Models.Database[] {
+    const configDatabases = this.controller!.config?.databases || [];
+    return configDatabases.map((db) => ({
+      $id: db.$id || ulid(),
+      $createdAt: DateTime.now().toISO(),
+      $updatedAt: DateTime.now().toISO(),
+      name: db.name,
+      enabled: true,
+    }));
+  }
+
+
+  /**
+   * Extract session information from current controller for preservation
+   */
+  private extractSessionFromController(): {
+    appwriteEndpoint: string;
+    appwriteProject: string;
+    appwriteKey?: string;
+    sessionCookie?: string;
+    sessionMetadata?: any;
+  } | undefined {
+    if (!this.controller?.config) {
+      return undefined;
     }
 
-    const collections = await this.selectCollections(
-      databases[0],
-      this.controller!.database!,
-      chalk.blue("Select local collections to push:"),
-      true,
-      true, // prefer local
-      true  // filter by selected database
-    );
+    const sessionInfo = this.controller.getSessionInfo();
+    const config = this.controller.config;
+
+    if (!config.appwriteEndpoint || !config.appwriteProject) {
+      return undefined;
+    }
+
+    const result: any = {
+      appwriteEndpoint: config.appwriteEndpoint,
+      appwriteProject: config.appwriteProject,
+      appwriteKey: config.appwriteKey
+    };
+
+    // Add session data if available
+    if (sessionInfo.hasSession) {
+      result.sessionCookie = (this.controller as any).sessionCookie;
+      result.sessionMetadata = (this.controller as any).sessionMetadata;
+    }
+
+    return result;
+  }
 
-    const { syncFunctions } = await inquirer.prompt([
-      {
-        type: "confirm",
-        name: "syncFunctions",
-        message: "Do you want to push local functions to remote?",
-        default: false,
-      },
-    ]);
 
+  private async detectConfigurationType(): Promise<void> {
     try {
-      // First sync databases and collections
-      await this.controller!.syncDb(databases, collections);
-      console.log(chalk.green("Database and collections pushed successfully"));
-
-      // Then handle functions if requested
-      if (syncFunctions && this.controller!.config?.functions?.length) {
-        const functions = await this.selectFunctions(
-          chalk.blue("Select local functions to push:"),
-          true,
-          true // prefer local
-        );
+      // Check for YAML config first
+      const yamlConfigPath = findYamlConfig(this.currentDir);
+      if (yamlConfigPath) {
+        this.isUsingTypeScriptConfig = false;
+        MessageFormatter.info("Using YAML configuration", { prefix: "Config" });
+        return;
+      }
 
-        for (const func of functions) {
-          try {
-            await this.controller!.deployFunction(func.name);
-            console.log(
-              chalk.green(`Function ${func.name} deployed successfully`)
-            );
-          } catch (error) {
-            console.error(
-              chalk.red(`Failed to deploy function ${func.name}:`),
-              error
-            );
-          }
+      // Then check for TypeScript config
+      const configPath = findAppwriteConfig(this.currentDir);
+      if (configPath) {
+        const tsConfigPath = join(configPath, 'appwriteConfig.ts');
+        if (fs.existsSync(tsConfigPath)) {
+          this.isUsingTypeScriptConfig = true;
+          MessageFormatter.info("TypeScript configuration detected", { prefix: "Config" });
+          MessageFormatter.info("Consider migrating to YAML for better organization", { prefix: "Config" });
+          return;
         }
       }
 
-      console.log(
-        chalk.green("Local configuration push completed successfully!")
-      );
+      // No config found
+      this.isUsingTypeScriptConfig = false;
+      MessageFormatter.info("No configuration file found", { prefix: "Config" });
     } catch (error) {
-      console.error(chalk.red("Failed to push local configuration:"), error);
-      throw error;
+      // Silently handle detection errors and continue
+      this.isUsingTypeScriptConfig = false;
     }
   }
 
-  private async synchronizeConfigurations(): Promise<void> {
-    console.log(chalk.blue("Synchronizing configurations..."));
-    await this.controller!.init();
-    
-    // Sync databases, collections, and buckets
-    const { syncDatabases } = await inquirer.prompt([
-      {
-        type: "confirm",
-        name: "syncDatabases",
-        message: "Do you want to synchronize databases, collections, and their buckets?",
-        default: true,
-      },
-    ]);
-
-    if (syncDatabases) {
-      const remoteDatabases = await fetchAllDatabases(
-        this.controller!.database!
-      );
-      
-      // Use the controller's synchronizeConfigurations method which handles collections properly
-      console.log(chalk.blue("Pulling collections and generating collection files..."));
-      await this.controller!.synchronizeConfigurations(remoteDatabases);
-      
-      // Also configure buckets for any new databases
-      const localDatabases = this.controller!.config?.databases || [];
-      const updatedConfig = await this.configureBuckets({
-        ...this.controller!.config!,
-        databases: [
-          ...localDatabases,
-          ...remoteDatabases.filter(
-            (rd) => !localDatabases.some((ld) => ld.name === rd.name)
-          ),
-        ],
-      });
-
-      this.controller!.config = updatedConfig;
-    }
-
-    // Then sync functions
-    const { syncFunctions } = await inquirer.prompt([
-      {
-        type: "confirm",
-        name: "syncFunctions",
-        message: "Do you want to synchronize functions?",
-        default: true,
-      },
-    ]);
-
-    if (syncFunctions) {
-      const remoteFunctions = await this.controller!.listAllFunctions();
-      const localFunctions = this.controller!.config?.functions || [];
-
-      const allFunctions = [
-        ...remoteFunctions,
-        ...localFunctions.filter(
-          (f) => !remoteFunctions.some((rf) => rf.$id === f.$id)
-        ),
-      ];
-
-      for (const func of allFunctions) {
-        const hasLocal = localFunctions.some((lf) => lf.$id === func.$id);
-        const hasRemote = remoteFunctions.some((rf) => rf.$id === func.$id);
-
-        if (hasLocal && hasRemote) {
-          // First try to find the function locally
-          let functionPath = join(
-            this.controller!.getAppwriteFolderPath()!,
-            "functions",
-            func.name
-          );
-
-          if (!fs.existsSync(functionPath)) {
-            console.log(
-              chalk.yellow(
-                `Function not found in primary location, searching subdirectories...`
-              )
-            );
-            const foundPath = await this.findFunctionInSubdirectories(
-              [this.controller!.getAppwriteFolderPath()!, process.cwd()],
-              func.name
-            );
-
-            if (foundPath) {
-              console.log(chalk.green(`Found function at: ${foundPath}`));
-              functionPath = foundPath;
-            }
-          }
-
-          const { preference } = await inquirer.prompt([
-            {
-              type: "list",
-              name: "preference",
-              message: `Function "${func.name}" ${
-                functionPath ? "found at " + functionPath : "not found locally"
-              }. What would you like to do?`,
-              choices: [
-                ...(functionPath
-                  ? [
-                      {
-                        name: "Keep local version (deploy to remote)",
-                        value: "local",
-                      },
-                    ]
-                  : []),
-                { name: "Use remote version (download)", value: "remote" },
-                { name: "Update config only", value: "config" },
-                { name: "Skip this function", value: "skip" },
-              ],
-            },
-          ]);
-
-          if (preference === "local" && functionPath) {
-            await this.controller!.deployFunction(func.name);
-          } else if (preference === "remote") {
-            await downloadLatestFunctionDeployment(
-              this.controller!.appwriteServer!,
-              func.$id,
-              join(this.controller!.getAppwriteFolderPath()!, "functions")
-            );
-          } else if (preference === "config") {
-            const remoteFunction = await getFunction(
-              this.controller!.appwriteServer!,
-              func.$id
-            );
-
-            const newFunction = {
-              $id: remoteFunction.$id,
-              name: remoteFunction.name,
-              runtime: remoteFunction.runtime as Runtime,
-              execute: remoteFunction.execute || [],
-              events: remoteFunction.events || [],
-              schedule: remoteFunction.schedule || "",
-              timeout: remoteFunction.timeout || 15,
-              enabled: remoteFunction.enabled !== false,
-              logging: remoteFunction.logging !== false,
-              entrypoint: remoteFunction.entrypoint || "src/index.ts",
-              commands: remoteFunction.commands || "npm install",
-              scopes: (remoteFunction.scopes || []) as FunctionScope[],
-              installationId: remoteFunction.installationId,
-              providerRepositoryId: remoteFunction.providerRepositoryId,
-              providerBranch: remoteFunction.providerBranch,
-              providerSilentMode: remoteFunction.providerSilentMode,
-              providerRootDirectory: remoteFunction.providerRootDirectory,
-              specification: remoteFunction.specification as Specification,
-            };
-
-            const existingIndex = this.controller!.config!.functions!.findIndex(
-              (f) => f.$id === remoteFunction.$id
-            );
-
-            if (existingIndex >= 0) {
-              this.controller!.config!.functions![existingIndex] = newFunction;
-            } else {
-              this.controller!.config!.functions!.push(newFunction);
-            }
-            console.log(
-              chalk.green(`Updated config for function: ${func.name}`)
-            );
-          }
-        } else if (hasLocal) {
-          // Similar check for local-only functions
-          let functionPath = join(
-            this.controller!.getAppwriteFolderPath()!,
-            "functions",
-            func.name
-          );
-
-          if (!fs.existsSync(functionPath)) {
-            const foundPath = await this.findFunctionInSubdirectories(
-              [this.controller!.getAppwriteFolderPath()!, process.cwd()],
-              func.name
-            );
-
-            if (foundPath) {
-              functionPath = foundPath;
-            }
-          }
-
-          const { action } = await inquirer.prompt([
-            {
-              type: "list",
-              name: "action",
-              message: `Function "${func.name}" ${
-                functionPath ? "found at " + functionPath : "not found locally"
-              }. What would you like to do?`,
-              choices: [
-                ...(functionPath
-                  ? [
-                      {
-                        name: "Deploy to remote",
-                        value: "deploy",
-                      },
-                    ]
-                  : []),
-                { name: "Skip this function", value: "skip" },
-              ],
-            },
-          ]);
-
-          if (action === "deploy" && functionPath) {
-            await this.controller!.deployFunction(func.name);
-          }
-        } else if (hasRemote) {
-          const { action } = await inquirer.prompt([
-            {
-              type: "list",
-              name: "action",
-              message: `Function "${func.name}" exists only remotely. What would you like to do?`,
-              choices: [
-                { name: "Update config only", value: "config" },
-                { name: "Download locally", value: "download" },
-                { name: "Skip this function", value: "skip" },
-              ],
-            },
-          ]);
-
-          if (action === "download") {
-            await downloadLatestFunctionDeployment(
-              this.controller!.appwriteServer!,
-              func.$id,
-              join(this.controller!.getAppwriteFolderPath()!, "functions")
-            );
-          } else if (action === "config") {
-            const remoteFunction = await getFunction(
-              this.controller!.appwriteServer!,
-              func.$id
-            );
-
-            const newFunction = {
-              $id: remoteFunction.$id,
-              name: remoteFunction.name,
-              runtime: remoteFunction.runtime as Runtime,
-              execute: remoteFunction.execute || [],
-              events: remoteFunction.events || [],
-              schedule: remoteFunction.schedule || "",
-              timeout: remoteFunction.timeout || 15,
-              enabled: remoteFunction.enabled !== false,
-              logging: remoteFunction.logging !== false,
-              entrypoint: remoteFunction.entrypoint || "src/index.ts",
-              commands: remoteFunction.commands || "npm install",
-              scopes: (remoteFunction.scopes || []) as FunctionScope[],
-              installationId: remoteFunction.installationId,
-              providerRepositoryId: remoteFunction.providerRepositoryId,
-              providerBranch: remoteFunction.providerBranch,
-              providerSilentMode: remoteFunction.providerSilentMode,
-              providerRootDirectory: remoteFunction.providerRootDirectory,
-              specification: remoteFunction.specification as Specification,
-            };
-
-            this.controller!.config!.functions =
-              this.controller!.config!.functions || [];
-            this.controller!.config!.functions.push(newFunction);
-            console.log(
-              chalk.green(`Added config for remote function: ${func.name}`)
-            );
-          }
-        }
-      }
-
-      // Schema generation and collection file writing is handled by controller.synchronizeConfigurations()
-    }
-
-    console.log(chalk.green("✨ Configurations synchronized successfully!"));
-  }
-
-  private async backupDatabase(): Promise<void> {
-    if (!this.controller!.database) {
-      throw new Error(
-        "Database is not initialized, is the config file correct & created?"
-      );
-    }
-    const databases = await fetchAllDatabases(this.controller!.database);
-
-    const selectedDatabases = await this.selectDatabases(
-      databases,
-      "Select databases to backup:"
-    );
-
-    for (const db of selectedDatabases) {
-      console.log(chalk.yellow(`Backing up database: ${db.name}`));
-      await this.controller!.backupDatabase(db);
-    }
-    MessageFormatter.success("Database backup completed", { prefix: "Backup" });
-  }
-
-  private async wipeDatabase(): Promise<void> {
-    if (!this.controller!.database || !this.controller!.storage) {
-      throw new Error(
-        "Database or Storage is not initialized, is the config file correct & created?"
-      );
-    }
-    const databases = await fetchAllDatabases(this.controller!.database);
-    const storage = await listBuckets(this.controller!.storage);
-
-    const selectedDatabases = await this.selectDatabases(
-      databases,
-      "Select databases to wipe:"
-    );
-
-    const { selectedStorage } = await inquirer.prompt([
-      {
-        type: "checkbox",
-        name: "selectedStorage",
-        message: "Select storage buckets to wipe:",
-        choices: storage.buckets.map((s) => ({ name: s.name, value: s.$id })),
-      },
-    ]);
-
-    const { wipeUsers } = await inquirer.prompt([
-      {
-        type: "confirm",
-        name: "wipeUsers",
-        message: "Do you want to wipe users as well?",
-        default: false,
-      },
-    ]);
-
-    const databaseNames = selectedDatabases.map(db => db.name);
-    const confirmed = await ConfirmationDialogs.confirmDatabaseWipe(databaseNames, {
-      includeStorage: selectedStorage.length > 0,
-      includeUsers: wipeUsers
-    });
-
-    if (confirmed) {
-      MessageFormatter.info("Starting wipe operation...", { prefix: "Wipe" });
-      for (const db of selectedDatabases) {
-        await this.controller!.wipeDatabase(db);
-      }
-      for (const bucketId of selectedStorage) {
-        await this.controller!.wipeDocumentStorage(bucketId);
-      }
-      if (wipeUsers) {
-        await this.controller!.wipeUsers();
-      }
-      MessageFormatter.success("Wipe operation completed", { prefix: "Wipe" });
-    } else {
-      MessageFormatter.info("Wipe operation cancelled", { prefix: "Wipe" });
-    }
-  }
-
-  private async wipeCollections(): Promise<void> {
-    if (!this.controller!.database) {
-      throw new Error(
-        "Database is not initialized, is the config file correct & created?"
-      );
-    }
-    const databases = await fetchAllDatabases(this.controller!.database);
-    const selectedDatabases = await this.selectDatabases(
-      databases,
-      "Select the database(s) containing the collections to wipe:",
-      true
-    );
-
-    for (const database of selectedDatabases) {
-      const collections = await this.selectCollections(
-        database,
-        this.controller!.database,
-        `Select collections to wipe from ${database.name}:`,
-        true,
-        undefined,
-        true
-      );
-
-      const collectionNames = collections.map(c => c.name);
-      const confirmed = await ConfirmationDialogs.confirmCollectionWipe(
-        database.name,
-        collectionNames
-      );
-
-      if (confirmed) {
-        MessageFormatter.info(
-          `Wiping selected collections from ${database.name}...`,
-          { prefix: "Wipe" }
-        );
-        for (const collection of collections) {
-          await this.controller!.wipeCollection(database, collection);
-          MessageFormatter.success(
-            `Collection ${collection.name} wiped successfully`,
-            { prefix: "Wipe" }
-          );
-        }
-      } else {
-        MessageFormatter.info(
-          `Wipe operation cancelled for ${database.name}`,
-          { prefix: "Wipe" }
-        );
-      }
-    }
-    MessageFormatter.success("Wipe collections operation completed", { prefix: "Wipe" });
-  }
-
-  private async generateSchemas(): Promise<void> {
-    console.log(chalk.yellow("Generating schemas..."));
-    
-    // Prompt user for schema type preference
-    const { schemaType } = await inquirer.prompt([
-      {
-        type: "list",
-        name: "schemaType",
-        message: "What type of schemas would you like to generate?",
-        choices: [
-          { name: "TypeScript (Zod) schemas", value: "zod" },
-          { name: "JSON schemas", value: "json" },
-          { name: "Both TypeScript and JSON schemas", value: "both" },
-        ],
-        default: "both",
-      },
-    ]);
-
-    // Get the config folder path (where the config file is located)
-    const configFolderPath = this.controller!.getAppwriteFolderPath();
-    if (!configFolderPath) {
-      MessageFormatter.error("Failed to get config folder path", undefined, { prefix: "Schemas" });
-      return;
-    }
-
-    // Create SchemaGenerator with the correct base path and generate schemas
-    const schemaGenerator = new SchemaGenerator(this.controller!.config!, configFolderPath);
-    schemaGenerator.generateSchemas({ format: schemaType, verbose: true });
-    
-    MessageFormatter.success("Schema generation completed", { prefix: "Schemas" });
-  }
-
-  private async generateConstants(): Promise<void> {
-    console.log(chalk.yellow("Generating cross-language constants..."));
-
-    if (!this.controller?.config) {
-      MessageFormatter.error("No configuration found", undefined, { prefix: "Constants" });
-      return;
-    }
-
-    // Prompt for languages
-    const { languages } = await inquirer.prompt([
-      {
-        type: "checkbox",
-        name: "languages",
-        message: "Select languages for constants generation:",
-        choices: [
-          { name: "TypeScript", value: "typescript", checked: true },
-          { name: "JavaScript", value: "javascript" },
-          { name: "Python", value: "python" },
-          { name: "PHP", value: "php" },
-          { name: "Dart", value: "dart" },
-          { name: "JSON", value: "json" },
-          { name: "Environment Variables", value: "env" },
-        ],
-        validate: (input) => {
-          if (input.length === 0) {
-            return "Please select at least one language";
-          }
-          return true;
-        },
-      },
-    ]);
-
-    // Determine default output directory based on config location
-    const configPath = this.controller!.getAppwriteFolderPath();
-    const defaultOutputDir = configPath 
-      ? path.join(configPath, "constants")
-      : path.join(process.cwd(), "constants");
-
-    // Prompt for output directory
-    const { outputDir } = await inquirer.prompt([
-      {
-        type: "input",
-        name: "outputDir",
-        message: "Output directory for constants files:",
-        default: defaultOutputDir,
-        validate: (input) => {
-          if (!input.trim()) {
-            return "Output directory cannot be empty";
-          }
-          return true;
-        },
-      },
-    ]);
-
-    try {
-      const { ConstantsGenerator } = await import("./utils/constantsGenerator.js");
-      const generator = new ConstantsGenerator(this.controller.config);
-      
-      MessageFormatter.info(`Generating constants for: ${languages.join(", ")}`, { prefix: "Constants" });
-      await generator.generateFiles(languages, outputDir);
-      
-      MessageFormatter.success(`Constants generated in ${outputDir}`, { prefix: "Constants" });
-    } catch (error) {
-      MessageFormatter.error("Failed to generate constants", error instanceof Error ? error : new Error(String(error)), { prefix: "Constants" });
-    }
-  }
-
-  private async importData(): Promise<void> {
-    console.log(chalk.yellow("Importing data..."));
-
-    const { doBackup } = await inquirer.prompt([
-      {
-        type: "confirm",
-        name: "doBackup",
-        message: "Do you want to perform a backup before importing?",
-        default: true,
-      },
-    ]);
-
-    const databases = await this.selectDatabases(
-      await fetchAllDatabases(this.controller!.database!),
-      "Select databases to import data into:",
-      true
-    );
-
-    const collections = await this.selectCollections(
-      databases[0],
-      this.controller!.database!,
-      "Select collections to import data into (leave empty for all):",
-      true
-    );
-
-    const { shouldWriteFile } = await inquirer.prompt([
-      {
-        type: "confirm",
-        name: "shouldWriteFile",
-        message: "Do you want to write the imported data to a file?",
-        default: false,
-      },
-    ]);
-
-    const options = {
-      databases,
-      collections: collections.map((c) => c.name),
-      doBackup,
-      importData: true,
-      shouldWriteFile,
-    };
-
-    try {
-      await this.controller!.importData(options);
-      console.log(chalk.green("Data import completed successfully."));
-    } catch (error) {
-      console.error(chalk.red("Error importing data:"), error);
-    }
-  }
-
-  private async transferData(): Promise<void> {
-    if (!this.controller!.database) {
-      throw new Error(
-        "Database is not initialized, is the config file correct & created?"
-      );
-    }
-
-    const { isRemote } = await inquirer.prompt([
-      {
-        type: "confirm",
-        name: "isRemote",
-        message: "Is this a remote transfer?",
-        default: false,
-      },
-    ]);
-
-    let sourceClient = this.controller!.database;
-    let targetClient: Databases;
-    let sourceDatabases: Models.Database[];
-    let targetDatabases: Models.Database[];
-    let remoteOptions:
-      | {
-          transferEndpoint: string;
-          transferProject: string;
-          transferKey: string;
-        }
-      | undefined;
-
-    if (isRemote) {
-      remoteOptions = await inquirer.prompt([
-        {
-          type: "input",
-          name: "transferEndpoint",
-          message: "Enter the remote endpoint:",
-        },
-        {
-          type: "input",
-          name: "transferProject",
-          message: "Enter the remote project ID:",
-        },
-        {
-          type: "input",
-          name: "transferKey",
-          message: "Enter the remote API key:",
-        },
-      ]);
-
-      const remoteClient = getClient(
-        remoteOptions!.transferEndpoint,
-        remoteOptions!.transferProject,
-        remoteOptions!.transferKey
-      );
-      targetClient = new Databases(remoteClient);
-
-      sourceDatabases = await fetchAllDatabases(sourceClient);
-      targetDatabases = await fetchAllDatabases(targetClient);
-    } else {
-      targetClient = sourceClient;
-      const allDatabases = await fetchAllDatabases(sourceClient);
-      sourceDatabases = targetDatabases = allDatabases;
-    }
-
-    const fromDbs = await this.selectDatabases(
-      sourceDatabases,
-      "Select the source database:",
-      false
-    );
-    const fromDb = fromDbs[0];
-    if (!fromDb) {
-      throw new Error("No source database selected");
-    }
-    const availableDbs = targetDatabases.filter((db) => db.$id !== fromDb.$id);
-    const targetDbs = await this.selectDatabases(
-      availableDbs,
-      "Select the target database:",
-      false
-    );
-    const targetDb = targetDbs[0];
-    if (!targetDb) {
-      throw new Error("No target database selected");
-    }
-
-    const selectedCollections = await this.selectCollections(
-      fromDb,
-      sourceClient,
-      "Select collections to transfer:",
-      true,
-      false // don't prefer local for transfers
-    );
-
-    const { transferStorage } = await inquirer.prompt([
-      {
-        type: "confirm",
-        name: "transferStorage",
-        message: "Do you want to transfer storage as well?",
-        default: false,
-      },
-    ]);
-
-    let sourceBucket, targetBucket;
-
-    if (transferStorage) {
-      const sourceStorage = new Storage(this.controller!.appwriteServer!);
-      const targetStorage = isRemote
-        ? new Storage(
-            getClient(
-              remoteOptions!.transferEndpoint,
-              remoteOptions!.transferProject,
-              remoteOptions!.transferKey
-            )
-          )
-        : sourceStorage;
-
-      const sourceBuckets = await listBuckets(sourceStorage);
-      const targetBuckets = isRemote
-        ? await listBuckets(targetStorage)
-        : sourceBuckets;
-
-      const sourceBucketPicked = await this.selectBuckets(
-        sourceBuckets.buckets,
-        "Select the source bucket:",
-        false
-      );
-      const targetBucketPicked = await this.selectBuckets(
-        targetBuckets.buckets,
-        "Select the target bucket:",
-        false
-      );
-      sourceBucket = sourceBucketPicked[0];
-      targetBucket = targetBucketPicked[0];
-    }
-
-    let transferOptions: TransferOptions = {
-      fromDb,
-      targetDb,
-      isRemote,
-      collections:
-        selectedCollections.length > 0
-          ? selectedCollections.map((c) => c.$id)
-          : undefined,
-      sourceBucket,
-      targetBucket,
-    };
-
-    if (isRemote && remoteOptions) {
-      transferOptions = {
-        ...transferOptions,
-        ...remoteOptions,
-      };
-    }
-
-    console.log(chalk.yellow("Transferring data..."));
-    await this.controller!.transferData(transferOptions);
-    console.log(chalk.green("Data transfer completed."));
-  }
-
-  private getLocalCollections(): Models.Collection[] {
-    const configCollections = this.controller!.config?.collections || [];
-    // @ts-expect-error - appwrite invalid types
-    return configCollections.map((c) => ({
-      $id: c.$id || ulid(),
-      $createdAt: DateTime.now().toISO(),
-      $updatedAt: DateTime.now().toISO(),
-      name: c.name,
-      enabled: c.enabled || true,
-      documentSecurity: c.documentSecurity || false,
-      attributes: c.attributes || [],
-      indexes: c.indexes || [],
-      $permissions: PermissionToAppwritePermission(c.$permissions) || [],
-      databaseId: c.databaseId!,
-    }));
-  }
-
-  private getLocalDatabases(): Models.Database[] {
-    const configDatabases = this.controller!.config?.databases || [];
-    return configDatabases.map((db) => ({
-      $id: db.$id || ulid(),
-      $createdAt: DateTime.now().toISO(),
-      $updatedAt: DateTime.now().toISO(),
-      name: db.name,
-      enabled: true,
-    }));
-  }
-
-  private async reloadConfig(): Promise<void> {
-    MessageFormatter.progress("Reloading configuration files...", { prefix: "Config" });
-    try {
-      await this.controller!.reloadConfig();
-      MessageFormatter.success("Configuration files reloaded successfully", { prefix: "Config" });
-    } catch (error) {
-      MessageFormatter.error("Failed to reload configuration files", error instanceof Error ? error : new Error(String(error)), { prefix: "Config" });
-    }
-  }
-
-  private async updateFunctionSpec(): Promise<void> {
-    const remoteFunctions = await listFunctions(
-      this.controller!.appwriteServer!,
-      [Query.limit(1000)]
-    );
-    const localFunctions = this.getLocalFunctions();
-
-    const allFunctions = [
-      ...remoteFunctions.functions,
-      ...localFunctions.filter(
-        (f) => !remoteFunctions.functions.some((rf) => rf.name === f.name)
-      ),
-    ];
-
-    const functionsToUpdate = await inquirer.prompt([
-      {
-        type: "checkbox",
-        name: "functionId",
-        message: "Select functions to update:",
-        choices: allFunctions.map((f) => ({
-          name: `${f.name} (${f.$id})${
-            localFunctions.some((lf) => lf.name === f.name)
-              ? " (Local)"
-              : " (Remote)"
-          }`,
-          value: f.$id,
-        })),
-        loop: true,
-      },
-    ]);
-
-    const specifications = await listSpecifications(
-      this.controller!.appwriteServer!
-    );
-    const { specification } = await inquirer.prompt([
-      {
-        type: "list",
-        name: "specification",
-        message: "Select new specification:",
-        choices: specifications.specifications.map((s) => ({
-          name: `${s.slug}`,
-          value: s.slug,
-        })),
-      },
-    ]);
-
-    try {
-      for (const functionId of functionsToUpdate.functionId) {
-        await this.controller!.updateFunctionSpecifications(
-          functionId,
-          specification
-        );
-        console.log(
-          chalk.green(
-            `Successfully updated function specification to ${specification}`
-          )
-        );
-      }
-    } catch (error) {
-      console.error(chalk.red("Error updating function specification:"), error);
-    }
-  }
-
-  private async detectConfigurationType(): Promise<void> {
-    try {
-      // Check for YAML config first
-      const yamlConfigPath = findYamlConfig(this.currentDir);
-      if (yamlConfigPath) {
-        this.isUsingTypeScriptConfig = false;
-        MessageFormatter.info("Using YAML configuration", { prefix: "Config" });
-        return;
-      }
-
-      // Then check for TypeScript config
-      const configPath = findAppwriteConfig(this.currentDir);
-      if (configPath) {
-        const tsConfigPath = join(configPath, 'appwriteConfig.ts');
-        if (fs.existsSync(tsConfigPath)) {
-          this.isUsingTypeScriptConfig = true;
-          MessageFormatter.info("TypeScript configuration detected", { prefix: "Config" });
-          MessageFormatter.info("Consider migrating to YAML for better organization", { prefix: "Config" });
-          return;
-        }
-      }
-
-      // No config found
-      this.isUsingTypeScriptConfig = false;
-      MessageFormatter.info("No configuration file found", { prefix: "Config" });
-    } catch (error) {
-      // Silently handle detection errors and continue
-      this.isUsingTypeScriptConfig = false;
-    }
-  }
-
-  private buildChoicesList(): string[] {
-    const allChoices = Object.values(CHOICES);
+  private buildChoicesList(): string[] {
+    const allChoices = Object.values(CHOICES);
     
     if (this.isUsingTypeScriptConfig) {
       // Place migration option at the top when TS config is detected
@@ -2060,302 +1040,4 @@ export class InteractiveCLI {
     }
   }
 
-  private async migrateTypeScriptConfig(): Promise<void> {
-    try {
-      MessageFormatter.info("Starting TypeScript to YAML configuration migration...", { prefix: "Migration" });
-      
-      // Perform the migration
-      await migrateConfig(this.currentDir);
-      
-      // Reset the detection flag
-      this.isUsingTypeScriptConfig = false;
-      
-      // Reset the controller to pick up the new config
-      this.controller = undefined;
-      
-      MessageFormatter.success("Migration completed successfully!", { prefix: "Migration" });
-      MessageFormatter.info("Your configuration has been migrated to the .appwrite directory structure", { prefix: "Migration" });
-      MessageFormatter.info("You can now use YAML configuration for easier management", { prefix: "Migration" });
-      
-    } catch (error) {
-      MessageFormatter.error("Migration failed", error instanceof Error ? error : new Error(String(error)), { prefix: "Migration" });
-    }
-  }
-
-  private async comprehensiveTransfer(): Promise<void> {
-    MessageFormatter.info("Starting comprehensive transfer configuration...", { prefix: "Transfer" });
-
-    try {
-      // Initialize controller to optionally load config if available (supports both YAML and TypeScript configs)
-      await this.initControllerIfNeeded();
-      
-      // Check if user has an appwrite config for easier setup
-      const hasAppwriteConfig = this.controller?.config?.appwriteEndpoint && 
-                               this.controller?.config?.appwriteProject && 
-                               this.controller?.config?.appwriteKey;
-
-      let sourceConfig: any;
-      let targetConfig: any;
-
-      if (hasAppwriteConfig) {
-        // Offer to use existing config for source
-        const { useConfigForSource } = await inquirer.prompt([
-          {
-            type: "confirm",
-            name: "useConfigForSource",
-            message: "Use your current appwriteConfig as the source?",
-            default: true,
-          },
-        ]);
-
-        if (useConfigForSource) {
-          sourceConfig = {
-            sourceEndpoint: this.controller!.config!.appwriteEndpoint,
-            sourceProject: this.controller!.config!.appwriteProject,
-            sourceKey: this.controller!.config!.appwriteKey,
-          };
-          MessageFormatter.info(`Using config source: ${sourceConfig.sourceEndpoint}`, { prefix: "Transfer" });
-        } else {
-          // Get source configuration manually
-          sourceConfig = await inquirer.prompt([
-            {
-              type: "input",
-              name: "sourceEndpoint",
-              message: "Enter the source Appwrite endpoint:",
-              validate: (input) => input.trim() !== "" || "Endpoint cannot be empty",
-            },
-            {
-              type: "input",
-              name: "sourceProject",
-              message: "Enter the source project ID:",
-              validate: (input) => input.trim() !== "" || "Project ID cannot be empty",
-            },
-            {
-              type: "password",
-              name: "sourceKey",
-              message: "Enter the source API key:",
-              validate: (input) => input.trim() !== "" || "API key cannot be empty",
-            },
-          ]);
-        }
-
-        // Offer to use existing config for target
-        const { useConfigForTarget } = await inquirer.prompt([
-          {
-            type: "confirm",
-            name: "useConfigForTarget",
-            message: "Use your current appwriteConfig as the target?",
-            default: false,
-          },
-        ]);
-
-        if (useConfigForTarget) {
-          targetConfig = {
-            targetEndpoint: this.controller!.config!.appwriteEndpoint,
-            targetProject: this.controller!.config!.appwriteProject,
-            targetKey: this.controller!.config!.appwriteKey,
-          };
-          MessageFormatter.info(`Using config target: ${targetConfig.targetEndpoint}`, { prefix: "Transfer" });
-        } else {
-          // Get target configuration manually
-          targetConfig = await inquirer.prompt([
-            {
-              type: "input",
-              name: "targetEndpoint",
-              message: "Enter the target Appwrite endpoint:",
-              validate: (input) => input.trim() !== "" || "Endpoint cannot be empty",
-            },
-            {
-              type: "input",
-              name: "targetProject",
-              message: "Enter the target project ID:",
-              validate: (input) => input.trim() !== "" || "Project ID cannot be empty",
-            },
-            {
-              type: "password",
-              name: "targetKey",
-              message: "Enter the target API key:",
-              validate: (input) => input.trim() !== "" || "API key cannot be empty",
-            },
-          ]);
-        }
-      } else {
-        // No appwrite config found, get both configurations manually
-        MessageFormatter.info("No appwriteConfig found, please enter source and target configurations manually", { prefix: "Transfer" });
-        
-        // Get source configuration
-        sourceConfig = await inquirer.prompt([
-          {
-            type: "input",
-            name: "sourceEndpoint",
-            message: "Enter the source Appwrite endpoint:",
-            validate: (input) => input.trim() !== "" || "Endpoint cannot be empty",
-          },
-          {
-            type: "input",
-            name: "sourceProject",
-            message: "Enter the source project ID:",
-            validate: (input) => input.trim() !== "" || "Project ID cannot be empty",
-          },
-          {
-            type: "password",
-            name: "sourceKey",
-            message: "Enter the source API key:",
-            validate: (input) => input.trim() !== "" || "API key cannot be empty",
-          },
-        ]);
-
-        // Get target configuration
-        targetConfig = await inquirer.prompt([
-          {
-            type: "input",
-            name: "targetEndpoint",
-            message: "Enter the target Appwrite endpoint:",
-            validate: (input) => input.trim() !== "" || "Endpoint cannot be empty",
-          },
-          {
-            type: "input",
-            name: "targetProject",
-            message: "Enter the target project ID:",
-            validate: (input) => input.trim() !== "" || "Project ID cannot be empty",
-          },
-          {
-            type: "password",
-            name: "targetKey",
-            message: "Enter the target API key:",
-            validate: (input) => input.trim() !== "" || "API key cannot be empty",
-          },
-        ]);
-      }
-
-      // Get transfer options
-      const transferOptions = await inquirer.prompt([
-        {
-          type: "checkbox",
-          name: "transferTypes",
-          message: "Select what to transfer:",
-          choices: [
-            { name: "👥 Users", value: "users", checked: true },
-            { name: "👥 Teams", value: "teams", checked: true },
-            { name: "🗄️ Databases", value: "databases", checked: true },
-            { name: "📦 Storage Buckets", value: "buckets", checked: true },
-            { name: "⚡ Functions", value: "functions", checked: true },
-          ],
-          validate: (input) => input.length > 0 || "Select at least one transfer type",
-        },
-        {
-          type: "list",
-          name: "concurrencyLimit",
-          message: "Select concurrency limit:",
-          choices: [
-            { name: "5 (Conservative) - Users: 2, Files: 1", value: 5 },
-            { name: "10 (Balanced) - Users: 5, Files: 2", value: 10 },
-            { name: "15 - Users: 7, Files: 3", value: 15 },
-            { name: "20 - Users: 10, Files: 5", value: 20 },
-            { name: "25 - Users: 12, Files: 6", value: 25 },
-            { name: "30 - Users: 15, Files: 7", value: 30 },
-            { name: "35 - Users: 17, Files: 8", value: 35 },
-            { name: "40 - Users: 20, Files: 10", value: 40 },
-            { name: "45 - Users: 22, Files: 11", value: 45 },
-            { name: "50 - Users: 25, Files: 12", value: 50 },
-            { name: "55 - Users: 27, Files: 13", value: 55 },
-            { name: "60 - Users: 30, Files: 15", value: 60 },
-            { name: "65 - Users: 32, Files: 16", value: 65 },
-            { name: "70 - Users: 35, Files: 17", value: 70 },
-            { name: "75 - Users: 37, Files: 18", value: 75 },
-            { name: "80 - Users: 40, Files: 20", value: 80 },
-            { name: "85 - Users: 42, Files: 21", value: 85 },
-            { name: "90 - Users: 45, Files: 22", value: 90 },
-            { name: "95 - Users: 47, Files: 23", value: 95 },
-            { name: "100 (Aggressive) - Users: 50, Files: 25", value: 100 },
-          ],
-          default: 10,
-        },
-        {
-          type: "confirm",
-          name: "dryRun",
-          message: "Run in dry-run mode (no actual changes)?",
-          default: false,
-        },
-      ]);
-
-      // Confirmation
-      const { confirmed } = await inquirer.prompt([
-        {
-          type: "confirm",
-          name: "confirmed",
-          message: `Are you sure you want to ${transferOptions.dryRun ? "dry-run" : "perform"} comprehensive transfer from ${sourceConfig.sourceEndpoint} to ${targetConfig.targetEndpoint}?`,
-          default: false,
-        },
-      ]);
-
-      if (!confirmed) {
-        MessageFormatter.info("Transfer cancelled by user", { prefix: "Transfer" });
-        return;
-      }
-
-      // Password preservation information
-      if (transferOptions.transferTypes.includes("users") && !transferOptions.dryRun) {
-        MessageFormatter.info("User Password Transfer Information:", { prefix: "Transfer" });
-        MessageFormatter.info("✅ Users with hashed passwords (Argon2, Bcrypt, Scrypt, MD5, SHA, PHPass) will preserve their passwords", { prefix: "Transfer" });
-        MessageFormatter.info("⚠️  Users without hash information will receive temporary passwords and need to reset", { prefix: "Transfer" });
-        MessageFormatter.info("🔒 All user data (preferences, labels, verification status) will be preserved", { prefix: "Transfer" });
-        
-        const { continueWithUsers } = await inquirer.prompt([
-          {
-            type: "confirm",
-            name: "continueWithUsers",
-            message: "Continue with user transfer?",
-            default: true,
-          },
-        ]);
-
-        if (!continueWithUsers) {
-          // Remove users from transfer types
-          transferOptions.transferTypes = transferOptions.transferTypes.filter((type: string) => type !== "users");
-          if (transferOptions.transferTypes.length === 0) {
-            MessageFormatter.info("No transfer types selected, cancelling", { prefix: "Transfer" });
-            return;
-          }
-        }
-      }
-
-      // Execute comprehensive transfer
-      const comprehensiveTransferOptions: ComprehensiveTransferOptions = {
-        sourceEndpoint: sourceConfig.sourceEndpoint,
-        sourceProject: sourceConfig.sourceProject,
-        sourceKey: sourceConfig.sourceKey,
-        targetEndpoint: targetConfig.targetEndpoint,
-        targetProject: targetConfig.targetProject,
-        targetKey: targetConfig.targetKey,
-        transferUsers: transferOptions.transferTypes.includes("users"),
-        transferTeams: transferOptions.transferTypes.includes("teams"),
-        transferDatabases: transferOptions.transferTypes.includes("databases"),
-        transferBuckets: transferOptions.transferTypes.includes("buckets"),
-        transferFunctions: transferOptions.transferTypes.includes("functions"),
-        concurrencyLimit: transferOptions.concurrencyLimit,
-        dryRun: transferOptions.dryRun,
-      };
-
-      const transfer = new ComprehensiveTransfer(comprehensiveTransferOptions);
-      const results = await transfer.execute();
-
-      // Display results
-      if (transferOptions.dryRun) {
-        MessageFormatter.success("Dry run completed successfully!", { prefix: "Transfer" });
-      } else {
-        MessageFormatter.success("Comprehensive transfer completed!", { prefix: "Transfer" });
-        if (transferOptions.transferTypes.includes("users") && results.users.transferred > 0) {
-          MessageFormatter.info("Users with preserved password hashes can log in with their original passwords", { prefix: "Transfer" });
-          MessageFormatter.info("Users with temporary passwords will need to reset their passwords", { prefix: "Transfer" });
-        }
-        if (transferOptions.transferTypes.includes("teams") && results.teams.transferred > 0) {
-          MessageFormatter.info("Team memberships have been transferred and may require user acceptance of invitations", { prefix: "Transfer" });
-        }
-      }
-
-    } catch (error) {
-      MessageFormatter.error("Comprehensive transfer failed", error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
-    }
-  }
 }