appwrite-utils-cli 1.0.5 → 1.0.7

package/dist/utils/constantsGenerator.js

@@ -0,0 +1,309 @@
+import fs from "fs/promises";
+import path from "path";
+import {} from "appwrite-utils";
+import { MessageFormatter } from "../shared/messageFormatter.js";
+export class ConstantsGenerator {
+    config;
+    constants;
+    constructor(config) {
+        this.config = config;
+        this.constants = this.extractConstants();
+    }
+    extractConstants() {
+        const constants = {
+            databases: {},
+            collections: {},
+            buckets: {},
+            functions: {}
+        };
+        // Extract database IDs
+        this.config.databases?.forEach(db => {
+            if (db.$id) {
+                const key = this.toConstantName(db.name || db.$id);
+                constants.databases[key] = db.$id;
+            }
+        });
+        // Extract collection IDs
+        this.config.collections?.forEach(collection => {
+            if (collection.$id) {
+                const key = this.toConstantName(collection.name || collection.$id);
+                constants.collections[key] = collection.$id;
+            }
+        });
+        // Extract bucket IDs
+        this.config.buckets?.forEach(bucket => {
+            if (bucket.$id) {
+                const key = this.toConstantName(bucket.name || bucket.$id);
+                constants.buckets[key] = bucket.$id;
+            }
+        });
+        // Extract function IDs
+        this.config.functions?.forEach(func => {
+            if (func.$id) {
+                const key = this.toConstantName(func.name || func.$id);
+                constants.functions[key] = func.$id;
+            }
+        });
+        return constants;
+    }
+    toConstantName(name) {
+        return name
+            .replace(/[^a-zA-Z0-9]/g, '_')
+            .replace(/_+/g, '_')
+            .replace(/^_|_$/g, '')
+            .toUpperCase();
+    }
+    toCamelCase(name) {
+        return name
+            .toLowerCase()
+            .replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+    }
+    toSnakeCase(name) {
+        return name.toLowerCase();
+    }
+    generateTypeScript() {
+        const { databases, collections, buckets, functions } = this.constants;
+        return `// Auto-generated Appwrite constants
+// Generated on ${new Date().toISOString()}
+
+export const DATABASE_IDS = {
+${Object.entries(databases).map(([key, value]) => `  ${key}: "${value}"`).join(',\n')}
+} as const;
+
+export const COLLECTION_IDS = {
+${Object.entries(collections).map(([key, value]) => `  ${key}: "${value}"`).join(',\n')}
+} as const;
+
+export const BUCKET_IDS = {
+${Object.entries(buckets).map(([key, value]) => `  ${key}: "${value}"`).join(',\n')}
+} as const;
+
+export const FUNCTION_IDS = {
+${Object.entries(functions).map(([key, value]) => `  ${key}: "${value}"`).join(',\n')}
+} as const;
+
+// Type helpers
+export type DatabaseId = typeof DATABASE_IDS[keyof typeof DATABASE_IDS];
+export type CollectionId = typeof COLLECTION_IDS[keyof typeof COLLECTION_IDS];
+export type BucketId = typeof BUCKET_IDS[keyof typeof BUCKET_IDS];
+export type FunctionId = typeof FUNCTION_IDS[keyof typeof FUNCTION_IDS];
+
+// Helper objects for runtime use
+export const ALL_DATABASE_IDS = Object.values(DATABASE_IDS);
+export const ALL_COLLECTION_IDS = Object.values(COLLECTION_IDS);
+export const ALL_BUCKET_IDS = Object.values(BUCKET_IDS);
+export const ALL_FUNCTION_IDS = Object.values(FUNCTION_IDS);
+`;
+    }
+    generateJavaScript() {
+        const { databases, collections, buckets, functions } = this.constants;
+        return `// Auto-generated Appwrite constants
+// Generated on ${new Date().toISOString()}
+
+export const DATABASE_IDS = {
+${Object.entries(databases).map(([key, value]) => `  ${key}: "${value}"`).join(',\n')}
+};
+
+export const COLLECTION_IDS = {
+${Object.entries(collections).map(([key, value]) => `  ${key}: "${value}"`).join(',\n')}
+};
+
+export const BUCKET_IDS = {
+${Object.entries(buckets).map(([key, value]) => `  ${key}: "${value}"`).join(',\n')}
+};
+
+export const FUNCTION_IDS = {
+${Object.entries(functions).map(([key, value]) => `  ${key}: "${value}"`).join(',\n')}
+};
+
+// Helper arrays for runtime use
+export const ALL_DATABASE_IDS = Object.values(DATABASE_IDS);
+export const ALL_COLLECTION_IDS = Object.values(COLLECTION_IDS);
+export const ALL_BUCKET_IDS = Object.values(BUCKET_IDS);
+export const ALL_FUNCTION_IDS = Object.values(FUNCTION_IDS);
+`;
+    }
+    generatePython() {
+        const { databases, collections, buckets, functions } = this.constants;
+        return `# Auto-generated Appwrite constants
+# Generated on ${new Date().toISOString()}
+
+class DatabaseIds:
+    """Database ID constants"""
+${Object.entries(databases).map(([key, value]) => `    ${key} = "${value}"`).join('\n')}
+
+class CollectionIds:
+    """Collection ID constants"""
+${Object.entries(collections).map(([key, value]) => `    ${key} = "${value}"`).join('\n')}
+
+class BucketIds:
+    """Bucket ID constants"""
+${Object.entries(buckets).map(([key, value]) => `    ${key} = "${value}"`).join('\n')}
+
+class FunctionIds:
+    """Function ID constants"""
+${Object.entries(functions).map(([key, value]) => `    ${key} = "${value}"`).join('\n')}
+
+# Helper dictionaries for runtime use
+DATABASE_ID_MAP = {
+${Object.entries(databases).map(([key, value]) => `    "${this.toSnakeCase(key)}": "${value}"`).join(',\n')}
+}
+
+COLLECTION_ID_MAP = {
+${Object.entries(collections).map(([key, value]) => `    "${this.toSnakeCase(key)}": "${value}"`).join(',\n')}
+}
+
+BUCKET_ID_MAP = {
+${Object.entries(buckets).map(([key, value]) => `    "${this.toSnakeCase(key)}": "${value}"`).join(',\n')}
+}
+
+FUNCTION_ID_MAP = {
+${Object.entries(functions).map(([key, value]) => `    "${this.toSnakeCase(key)}": "${value}"`).join(',\n')}
+}
+`;
+    }
+    generatePHP() {
+        const { databases, collections, buckets, functions } = this.constants;
+        return `<?php
+// Auto-generated Appwrite constants
+// Generated on ${new Date().toISOString()}
+
+class AppwriteConstants {
+    
+    const DATABASE_IDS = [
+${Object.entries(databases).map(([key, value]) => `        '${key}' => '${value}'`).join(',\n')}
+    ];
+    
+    const COLLECTION_IDS = [
+${Object.entries(collections).map(([key, value]) => `        '${key}' => '${value}'`).join(',\n')}
+    ];
+    
+    const BUCKET_IDS = [
+${Object.entries(buckets).map(([key, value]) => `        '${key}' => '${value}'`).join(',\n')}
+    ];
+    
+    const FUNCTION_IDS = [
+${Object.entries(functions).map(([key, value]) => `        '${key}' => '${value}'`).join(',\n')}
+    ];
+    
+    /**
+     * Get all database IDs as array
+     */
+    public static function getAllDatabaseIds(): array {
+        return array_values(self::DATABASE_IDS);
+    }
+    
+    /**
+     * Get all collection IDs as array
+     */
+    public static function getAllCollectionIds(): array {
+        return array_values(self::COLLECTION_IDS);
+    }
+    
+    /**
+     * Get all bucket IDs as array
+     */
+    public static function getAllBucketIds(): array {
+        return array_values(self::BUCKET_IDS);
+    }
+    
+    /**
+     * Get all function IDs as array
+     */
+    public static function getAllFunctionIds(): array {
+        return array_values(self::FUNCTION_IDS);
+    }
+}
+`;
+    }
+    generateDart() {
+        const { databases, collections, buckets, functions } = this.constants;
+        return `// Auto-generated Appwrite constants
+// Generated on ${new Date().toISOString()}
+
+class AppwriteConstants {
+  
+  static const Map<String, String> databaseIds = {
+${Object.entries(databases).map(([key, value]) => `    '${this.toCamelCase(key)}': '${value}'`).join(',\n')}
+  };
+  
+  static const Map<String, String> collectionIds = {
+${Object.entries(collections).map(([key, value]) => `    '${this.toCamelCase(key)}': '${value}'`).join(',\n')}
+  };
+  
+  static const Map<String, String> bucketIds = {
+${Object.entries(buckets).map(([key, value]) => `    '${this.toCamelCase(key)}': '${value}'`).join(',\n')}
+  };
+  
+  static const Map<String, String> functionIds = {
+${Object.entries(functions).map(([key, value]) => `    '${this.toCamelCase(key)}': '${value}'`).join(',\n')}
+  };
+  
+  // Helper getters for individual IDs
+${Object.entries(databases).map(([key, value]) => `  static String get ${this.toCamelCase(key)}DatabaseId => '${value}';`).join('\n')}
+  
+${Object.entries(collections).map(([key, value]) => `  static String get ${this.toCamelCase(key)}CollectionId => '${value}';`).join('\n')}
+  
+${Object.entries(buckets).map(([key, value]) => `  static String get ${this.toCamelCase(key)}BucketId => '${value}';`).join('\n')}
+  
+${Object.entries(functions).map(([key, value]) => `  static String get ${this.toCamelCase(key)}FunctionId => '${value}';`).join('\n')}
+}
+`;
+    }
+    generateJSON() {
+        return JSON.stringify({
+            meta: {
+                generated: new Date().toISOString(),
+                generator: "appwrite-utils-cli"
+            },
+            databases: this.constants.databases,
+            collections: this.constants.collections,
+            buckets: this.constants.buckets,
+            functions: this.constants.functions
+        }, null, 2);
+    }
+    generateEnv() {
+        const { databases, collections, buckets, functions } = this.constants;
+        const lines = [
+            "# Auto-generated Appwrite constants",
+            `# Generated on ${new Date().toISOString()}`,
+            "",
+            "# Database IDs",
+            ...Object.entries(databases).map(([key, value]) => `DATABASE_${key}=${value}`),
+            "",
+            "# Collection IDs",
+            ...Object.entries(collections).map(([key, value]) => `COLLECTION_${key}=${value}`),
+            "",
+            "# Bucket IDs",
+            ...Object.entries(buckets).map(([key, value]) => `BUCKET_${key}=${value}`),
+            "",
+            "# Function IDs",
+            ...Object.entries(functions).map(([key, value]) => `FUNCTION_${key}=${value}`)
+        ];
+        return lines.join('\n');
+    }
+    async generateFiles(languages, outputDir) {
+        await fs.mkdir(outputDir, { recursive: true });
+        const generators = {
+            typescript: () => ({ content: this.generateTypeScript(), filename: "appwrite-constants.ts" }),
+            javascript: () => ({ content: this.generateJavaScript(), filename: "appwrite-constants.js" }),
+            python: () => ({ content: this.generatePython(), filename: "appwrite_constants.py" }),
+            php: () => ({ content: this.generatePHP(), filename: "AppwriteConstants.php" }),
+            dart: () => ({ content: this.generateDart(), filename: "appwrite_constants.dart" }),
+            json: () => ({ content: this.generateJSON(), filename: "appwrite-constants.json" }),
+            env: () => ({ content: this.generateEnv(), filename: ".env.appwrite" })
+        };
+        for (const language of languages) {
+            const generator = generators[language];
+            if (generator) {
+                const { content, filename } = generator();
+                const filePath = path.join(outputDir, filename);
+                await fs.writeFile(filePath, content, 'utf-8');
+                MessageFormatter.success(`Generated ${language} constants: ${filePath}`, { prefix: "Constants" });
+            }
+            else {
+                MessageFormatter.error(`Unsupported language: ${language}`, undefined, { prefix: "Constants" });
+            }
+        }
+    }
+}

package/dist/utils/loadConfigs.js

@@ -7,6 +7,7 @@ import chalk from "chalk";
 import { findYamlConfig, loadYamlConfig } from "../config/yamlConfig.js";
 import yaml from "js-yaml";
 import { z } from "zod";
+import { MessageFormatter } from "../shared/messageFormatter.js";
 /**
  * Recursively searches for configuration files starting from the given directory.
  * Priority: 1) YAML configs in .appwrite directories, 2) appwriteConfig.ts files in subdirectories
@@ -79,7 +80,6 @@ const findAppwriteConfigTS = (dir, depth = 0) => {
         // First check current directory for appwriteConfig.ts
         for (const entry of entries) {
             if (entry.isFile() && entry.name === "appwriteConfig.ts") {
-                console.log(`Found appwriteConfig.ts at: ${path.join(dir, entry.name)}`);
                 return path.join(dir, entry.name);
             }
         }
@@ -94,7 +94,6 @@ const findAppwriteConfigTS = (dir, depth = 0) => {
     }
     catch (error) {
         // Ignore directory access errors
-        console.log(`Error accessing directory ${dir}:`, error);
     }
     return null;
 };
@@ -134,7 +133,6 @@ export const loadConfigWithPath = async (configDir) => {
         if (fs.existsSync(configPath)) {
             const unregister = register(); // Register tsx enhancement
             try {
-                console.log(`Loading TypeScript config from: ${configPath}`);
                 const configUrl = pathToFileURL(configPath).href;
                 const configModule = (await import(configUrl));
                 config = configModule.default?.default || configModule.default || configModule;
@@ -214,7 +212,6 @@ export const loadConfig = async (configDir) => {
     // First try to find and load YAML config
     const yamlConfigPath = findYamlConfig(configDir);
     if (yamlConfigPath) {
-        console.log(`Loading YAML config from: ${yamlConfigPath}`);
         config = await loadYamlConfig(yamlConfigPath);
         actualConfigPath = yamlConfigPath;
     }
@@ -225,7 +222,6 @@ export const loadConfig = async (configDir) => {
         if (fs.existsSync(configPath)) {
             const unregister = register(); // Register tsx enhancement
             try {
-                console.log(`Loading TypeScript config from: ${configPath}`);
                 const configUrl = pathToFileURL(configPath).href;
                 const configModule = (await import(configUrl));
                 config = configModule.default?.default || configModule.default || configModule;
@@ -300,6 +296,10 @@ export const loadConfig = async (configDir) => {
     else {
         config.collections = config.collections || [];
     }
+    // Log successful config loading
+    if (actualConfigPath) {
+        MessageFormatter.success(`Loaded config from: ${actualConfigPath}`, { prefix: "Config" });
+    }
     return config;
 };
 export const findFunctionsDir = (dir, depth = 0) => {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "appwrite-utils-cli",
   "description": "Appwrite Utility Functions to help with database management, data conversion, data import, migrations, and much more. Meant to be used as a CLI tool, I do not recommend installing this in frontend environments.",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "main": "src/main.ts",
   "type": "module",
   "repository": {

package/src/config/yamlConfig.ts

@@ -256,18 +256,14 @@ export const findYamlConfig = (startDir: string): string | null => {
     path.join(startDir, "appwrite.yml"),
   ];
 
-  console.log(`DEBUG: Checking YAML paths in ${startDir}:`);
   for (const configPath of possiblePaths) {
-    console.log(`  - ${configPath}: ${fs.existsSync(configPath)}`);
     if (fs.existsSync(configPath)) {
       return configPath;
     }
   }
 
   // Recursively search subdirectories for .appwrite folders
-  console.log(`DEBUG: Starting recursive search from ${startDir}`);
   const yamlConfigInSubdirs = findYamlConfigRecursive(startDir);
-  console.log(`DEBUG: Recursive search result: ${yamlConfigInSubdirs}`);
   if (yamlConfigInSubdirs) {
     return yamlConfigInSubdirs;
   }
@@ -336,27 +332,22 @@ const shouldIgnoreDirectory = (dirName: string): boolean => {
 const findYamlConfigRecursive = (dir: string, depth: number = 0): string | null => {
   // Limit search depth to prevent infinite recursion
   if (depth > 5) {
-    console.log(`DEBUG: Stopping search at depth ${depth} in ${dir}`);
     return null;
   }
 
   if (shouldIgnoreDirectory(path.basename(dir))) {
-    console.log(`DEBUG: Ignoring directory ${dir}`);
     return null;
   }
 
   try {
     const entries = fs.readdirSync(dir, { withFileTypes: true });
-    console.log(`DEBUG: Searching directory ${dir} at depth ${depth}, found ${entries.length} entries`);
 
     for (const entry of entries) {
       if (entry.isDirectory() && !shouldIgnoreDirectory(entry.name)) {
         const fullPath = path.join(dir, entry.name);
-        console.log(`DEBUG: Checking subdirectory: ${fullPath}`);
         
         // Check if this is an .appwrite directory
         if (entry.name === ".appwrite") {
-          console.log(`DEBUG: Found .appwrite directory at ${fullPath}`);
           const configPaths = [
             path.join(fullPath, "appwriteConfig.yaml"),
             path.join(fullPath, "appwriteConfig.yml"),

package/src/interactiveCLI.ts

@@ -41,6 +41,7 @@ import {
 } 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 { SchemaGenerator } from "./shared/schemaGenerator.js";
 import { ConfirmationDialogs } from "./shared/confirmationDialogs.js";
@@ -51,23 +52,24 @@ import { findYamlConfig, addFunctionToYamlConfig } from "./config/yamlConfig.js"
 
 enum CHOICES {
   MIGRATE_CONFIG = "🔄 Migrate TypeScript config to YAML (.appwrite structure)",
-  CREATE_COLLECTION_CONFIG = "Create collection config file",
-  CREATE_FUNCTION = "Create a new function, from scratch or using a template",
-  DEPLOY_FUNCTION = "Deploy function(s)",
-  DELETE_FUNCTION = "Delete function",
-  SETUP_DIRS_FILES = "Setup directories and files",
-  SETUP_DIRS_FILES_WITH_EXAMPLE_DATA = "Setup directories and files with example data",
-  SYNC_DB = "Push local config to Appwrite",
-  SYNCHRONIZE_CONFIGURATIONS = "Synchronize configurations - Pull from Appwrite and write to local config",
-  TRANSFER_DATA = "Transfer data",
-  BACKUP_DATABASE = "Backup database",
-  WIPE_DATABASE = "Wipe database",
-  WIPE_COLLECTIONS = "Wipe collections",
-  GENERATE_SCHEMAS = "Generate schemas",
-  IMPORT_DATA = "Import data",
-  RELOAD_CONFIG = "Reload configuration files",
-  UPDATE_FUNCTION_SPEC = "Update function specifications",
-  EXIT = "Exit",
+  CREATE_COLLECTION_CONFIG = "📄 Create collection config file",
+  CREATE_FUNCTION = "⚡ Create a new function, from scratch or using a template",
+  DEPLOY_FUNCTION = "🚀 Deploy function(s)",
+  DELETE_FUNCTION = "🗑️ Delete function",
+  SETUP_DIRS_FILES = "📁 Setup directories and files",
+  SETUP_DIRS_FILES_WITH_EXAMPLE_DATA = "📁✨ Setup directories and files with example data",
+  SYNC_DB = "⬆️ Push local config to Appwrite",
+  SYNCHRONIZE_CONFIGURATIONS = "🔄 Synchronize configurations - Pull from Appwrite and write to local config",
+  TRANSFER_DATA = "📦 Transfer data",
+  BACKUP_DATABASE = "💾 Backup database",
+  WIPE_DATABASE = "🧹 Wipe database",
+  WIPE_COLLECTIONS = "🧹 Wipe collections",
+  GENERATE_SCHEMAS = "🏗️ Generate schemas",
+  GENERATE_CONSTANTS = "📋 Generate cross-language constants (TypeScript, Python, PHP, Dart, etc.)",
+  IMPORT_DATA = "📥 Import data",
+  RELOAD_CONFIG = "🔄 Reload configuration files",
+  UPDATE_FUNCTION_SPEC = "⚙️ Update function specifications",
+  EXIT = "👋 Exit",
 }
 
 export class InteractiveCLI {
@@ -159,6 +161,10 @@ export class InteractiveCLI {
           await this.initControllerIfNeeded();
           await this.generateSchemas();
           break;
+        case CHOICES.GENERATE_CONSTANTS:
+          await this.initControllerIfNeeded();
+          await this.generateConstants();
+          break;
         case CHOICES.IMPORT_DATA:
           await this.initControllerIfNeeded();
           await this.importData();
@@ -1595,6 +1601,73 @@ export class InteractiveCLI {
     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..."));
 

package/src/main.ts

@@ -15,6 +15,7 @@ import chalk from "chalk";
 import { listSpecifications } from "./functions/methods.js";
 import { MessageFormatter } from "./shared/messageFormatter.js";
 import { ConfirmationDialogs } from "./shared/confirmationDialogs.js";
+import path from "path";
 
 interface CliOptions {
   config?: string;
@@ -49,6 +50,9 @@ interface CliOptions {
   functionId?: string;
   specification?: string;
   migrateConfig?: boolean;
+  generateConstants?: boolean;
+  constantsLanguages?: string;
+  constantsOutput?: string;
 }
 
 type ParsedArgv = ArgumentsCamelCase<CliOptions>;
@@ -203,6 +207,21 @@ const argv = yargs(hideBin(process.argv))
     type: "boolean",
     description: "Migrate appwriteConfig.ts to .appwrite structure with YAML configuration",
   })
+  .option("generateConstants", {
+    alias: ["constants"],
+    type: "boolean", 
+    description: "Generate cross-language constants file with database, collection, bucket, and function IDs",
+  })
+  .option("constantsLanguages", {
+    type: "string",
+    description: "Comma-separated list of languages for constants (typescript,javascript,python,php,dart,json,env)",
+    default: "typescript",
+  })
+  .option("constantsOutput", {
+    type: "string",
+    description: "Output directory for generated constants files (default: config-folder/constants)",
+    default: "auto",
+  })
   .parse() as ParsedArgv;
 
 async function main() {
@@ -235,6 +254,40 @@ async function main() {
       return;
     }
 
+    if (argv.generateConstants) {
+      const { ConstantsGenerator } = await import("./utils/constantsGenerator.js");
+      type SupportedLanguage = import("./utils/constantsGenerator.js").SupportedLanguage;
+      
+      if (!controller.config) {
+        MessageFormatter.error("No Appwrite configuration found", undefined, { prefix: "Constants" });
+        return;
+      }
+
+      const languages = argv.constantsLanguages!.split(",").map(l => l.trim()) as SupportedLanguage[];
+      
+      // Determine output directory - use config folder/constants by default, or custom path if specified
+      let outputDir: string;
+      if (argv.constantsOutput === "auto") {
+        // Default case: use config directory + constants, fallback to current directory
+        const configPath = controller.getAppwriteFolderPath();
+        outputDir = configPath 
+          ? path.join(configPath, "constants")
+          : path.join(process.cwd(), "constants");
+      } else {
+        // Custom output directory specified
+        outputDir = argv.constantsOutput!;
+      }
+      
+      MessageFormatter.info(`Generating constants for languages: ${languages.join(", ")}`, { prefix: "Constants" });
+      
+      const generator = new ConstantsGenerator(controller.config);
+      await generator.generateFiles(languages, outputDir);
+      
+      operationStats.generatedConstants = languages.length;
+      MessageFormatter.success(`Constants generated in ${outputDir}`, { prefix: "Constants" });
+      return;
+    }
+
     if (!controller.config) {
       MessageFormatter.error("No Appwrite connection found", undefined, { prefix: "CLI" });
       return;