appwrite-utils-cli 1.8.8 → 1.9.1

package/CHANGELOG.md

@@ -25,3 +25,11 @@ All notable changes to this project will be documented in this file.
 - Enhancement: Interactive selection adds “Use same selection as before” when choosing tables per database, speeding up multi-DB workflows.
 - Behavior: Non-interactive `--push` with both `--dbIds` and `--collectionIds` is fully non-interactive. The provided IDs are applied as-is to every selected database and the confirmation summary is skipped.
 - Improvement: Selective push reloads local config from disk before pushing to ensure the latest YAML/TS changes are used.
+- Fix: Sync-from-Appwrite now captures function `scopes` and writes them to config; deployments use `scopes` from either central config or `.fnconfig.yaml`.
+- Change: Removed global prompt to choose between central `config.yaml` and per-function `.fnconfig.yaml` during function deployments. The tool now prompts per function only when both sources exist for that function (with an option to merge where `.fnconfig` overrides).
+
+## 1.8.9 - 2025-10-29
+
+- Fix: Functions sync now fetches full details via `getFunction` per function to reliably capture `scopes` (prevents empty scopes in some environments).
+- Confirmed schema: YAML `appwrite-config.schema.json` supports `functions[].dirPath`; writers preserve `dirPath` when present.
+- Polish: Per-function config source selection is now applied at deploy time when both central and `.fnconfig.yaml` are present.

package/dist/adapters/DatabaseAdapter.d.ts

@@ -105,6 +105,15 @@ export interface CreateAttributeParams {
     default?: any;
     array?: boolean;
     encrypt?: boolean;
+    min?: number;
+    max?: number;
+    elements?: string[];
+    relatedCollection?: string;
+    relationType?: 'oneToOne' | 'manyToOne' | 'oneToMany' | 'manyToMany';
+    twoWay?: boolean;
+    twoWayKey?: string;
+    onDelete?: 'setNull' | 'cascade' | 'restrict';
+    side?: 'parent' | 'child';
     [key: string]: any;
 }
 export interface UpdateAttributeParams {

package/dist/adapters/LegacyAdapter.js

@@ -316,7 +316,7 @@ export class LegacyAdapter extends BaseAdapter {
                         relatedCollectionId: params.relatedCollection || '',
                         type: (params.type || 'oneToOne'),
                         twoWay: params.twoWay ?? false,
-                        onDelete: params.onDelete || 'restrict'
+                        onDelete: (params.onDelete || 'restrict')
                     });
                     break;
                 default:

package/dist/adapters/TablesDBAdapter.js

@@ -308,10 +308,10 @@ export class TablesDBAdapter extends BaseAdapter {
                         tableId: params.tableId,
                         key: params.key,
                         relatedTableId: params.relatedCollection || '',
-                        type: (params.type || 'oneToOne'),
+                        type: (params.relationType || 'oneToOne'),
                         twoWay: params.twoWay ?? false,
                         twoWayKey: params.twoWayKey,
-                        onDelete: params.onDelete || 'restrict'
+                        onDelete: (params.onDelete || 'restrict')
                     });
                     break;
                 default:
@@ -505,7 +505,21 @@ export class TablesDBAdapter extends BaseAdapter {
             let queries;
             // Wipe mode: use Query.limit for deleting without fetching
             if (params.rowIds.length === 0) {
-                const batchSize = params.batchSize || 250;
+                const batchSize = params.batchSize || 1000;
+                // Validation: Ensure table exists before wiping
+                try {
+                    await this.getTable({
+                        databaseId: params.databaseId,
+                        tableId: params.tableId
+                    });
+                }
+                catch (error) {
+                    const errorMessage = error?.message || String(error);
+                    if (errorMessage.toLowerCase().includes('not found') || error?.code === 404) {
+                        throw new AdapterError(`Table '${params.tableId}' not found in database '${params.databaseId}'`, 'TABLE_NOT_FOUND', error);
+                    }
+                    throw error; // Re-throw other errors
+                }
                 queries = [Query.limit(batchSize)];
             }
             // Specific IDs mode: chunk into batches of 80-90 to stay within Appwrite limits
@@ -526,7 +540,18 @@ export class TablesDBAdapter extends BaseAdapter {
             };
         }
         catch (error) {
-            throw new AdapterError(`Failed to bulk delete rows: ${error instanceof Error ? error.message : 'Unknown error'}`, 'BULK_DELETE_ROWS_FAILED', error instanceof Error ? error : undefined);
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            // Enhanced error categorization
+            if (errorMessage.toLowerCase().includes('not found') || error?.code === 404) {
+                throw new AdapterError(`Table or rows not found: ${errorMessage}`, 'NOT_FOUND', error instanceof Error ? error : undefined);
+            }
+            else if (errorMessage.toLowerCase().includes('permission') || errorMessage.toLowerCase().includes('unauthorized') || error?.code === 403) {
+                throw new AdapterError(`Permission denied for bulk delete: ${errorMessage}`, 'PERMISSION_DENIED', error instanceof Error ? error : undefined);
+            }
+            else if (errorMessage.toLowerCase().includes('rate limit') || error?.code === 429) {
+                throw new AdapterError(`Rate limit exceeded during bulk delete: ${errorMessage}`, 'RATE_LIMIT', error instanceof Error ? error : undefined);
+            }
+            throw new AdapterError(`Failed to bulk delete rows: ${errorMessage}`, 'BULK_DELETE_ROWS_FAILED', error instanceof Error ? error : undefined);
         }
     }
     // Metadata and Capabilities

package/dist/cli/commands/databaseCommands.d.ts

@@ -10,4 +10,5 @@ export declare const databaseCommands: {
     executeUnifiedBackup(cli: InteractiveCLI, trackingDatabaseId: string, scope: any): Promise<void>;
     wipeDatabase(cli: InteractiveCLI): Promise<void>;
     wipeCollections(cli: InteractiveCLI): Promise<void>;
+    wipeTablesData(cli: InteractiveCLI): Promise<void>;
 };

package/dist/cli/commands/databaseCommands.js

@@ -1,6 +1,7 @@
 import inquirer from "inquirer";
 import chalk from "chalk";
 import { join } from "node:path";
+import { Query } from "node-appwrite";
 import { MessageFormatter } from "../../shared/messageFormatter.js";
 import { ConfirmationDialogs } from "../../shared/confirmationDialogs.js";
 import { SelectionDialogs } from "../../shared/selectionDialogs.js";
@@ -8,6 +9,7 @@ import { logger } from "../../shared/logging.js";
 import { fetchAllDatabases } from "../../databases/methods.js";
 import { listBuckets } from "../../storage/methods.js";
 import { getFunction, downloadLatestFunctionDeployment } from "../../functions/methods.js";
+import { wipeTableRows } from "../../collections/wipeOperations.js";
 export const databaseCommands = {
     async syncDb(cli) {
         MessageFormatter.progress("Pushing local configuration to Appwrite...", { prefix: "Database" });
@@ -550,5 +552,93 @@ export const databaseCommands = {
             }
         }
         MessageFormatter.success("Wipe collections operation completed", { prefix: "Wipe" });
+    },
+    async wipeTablesData(cli) {
+        const controller = cli.controller;
+        if (!controller?.adapter) {
+            throw new Error("Database adapter is not initialized. TablesDB operations require adapter support.");
+        }
+        try {
+            // Step 1: Select database (single selection for clearer UX)
+            const databases = await fetchAllDatabases(controller.database);
+            if (!databases || databases.length === 0) {
+                MessageFormatter.warning("No databases found", { prefix: "Wipe" });
+                return;
+            }
+            const { selectedDatabase } = await inquirer.prompt([
+                {
+                    type: "list",
+                    name: "selectedDatabase",
+                    message: "Select database containing tables to wipe:",
+                    choices: databases.map((db) => ({
+                        name: `${db.name} (${db.$id})`,
+                        value: db
+                    }))
+                }
+            ]);
+            const database = selectedDatabase;
+            // Step 2: Get available tables
+            const adapter = controller.adapter;
+            const tablesResponse = await adapter.listTables({
+                databaseId: database.$id,
+                queries: [Query.limit(500)]
+            });
+            const availableTables = tablesResponse.tables || [];
+            if (availableTables.length === 0) {
+                MessageFormatter.warning(`No tables found in database: ${database.name}`, { prefix: "Wipe" });
+                return;
+            }
+            // Step 3: Select tables using existing SelectionDialogs
+            const selectedTableIds = await SelectionDialogs.selectTablesForDatabase(database.$id, database.name, availableTables, [], // No configured tables context needed for wipe
+            {
+                showSelectAll: true,
+                allowNewOnly: false,
+                defaultSelected: []
+            });
+            if (selectedTableIds.length === 0) {
+                MessageFormatter.warning("No tables selected. Operation cancelled.", { prefix: "Wipe" });
+                return;
+            }
+            // Step 4: Show confirmation with table details
+            const selectedTables = availableTables.filter((t) => selectedTableIds.includes(t.$id));
+            const tableNames = selectedTables.map((t) => t.name);
+            console.log(chalk.yellow.bold("\n⚠️  WARNING: Table Row Wipe Operation"));
+            console.log(chalk.yellow("This will delete ALL ROWS from the selected tables."));
+            console.log(chalk.yellow("The table structures will remain intact.\n"));
+            console.log(chalk.cyan("Database:"), chalk.white(database.name));
+            console.log(chalk.cyan("Tables to wipe:"));
+            tableNames.forEach((name) => console.log(chalk.white(`  • ${name}`)));
+            console.log();
+            const { confirmed } = await inquirer.prompt([
+                {
+                    type: "confirm",
+                    name: "confirmed",
+                    message: chalk.red.bold("Are you ABSOLUTELY SURE you want to wipe these table rows?"),
+                    default: false
+                }
+            ]);
+            if (!confirmed) {
+                MessageFormatter.info("Wipe operation cancelled by user", { prefix: "Wipe" });
+                return;
+            }
+            // Step 5: Execute wipe using existing wipeTableRows function
+            MessageFormatter.progress("Starting table row wipe operation...", { prefix: "Wipe" });
+            for (const table of selectedTables) {
+                try {
+                    MessageFormatter.info(`Wiping rows from table: ${table.name}`, { prefix: "Wipe" });
+                    // Use existing wipeTableRows from wipeOperations.ts
+                    await wipeTableRows(adapter, database.$id, table.$id);
+                    MessageFormatter.success(`Successfully wiped rows from table: ${table.name}`, { prefix: "Wipe" });
+                }
+                catch (error) {
+                    MessageFormatter.error(`Failed to wipe table ${table.name}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Wipe" });
+                }
+            }
+            MessageFormatter.success(`Wipe operation completed for ${selectedTables.length} table(s)`, { prefix: "Wipe" });
+        }
+        catch (error) {
+            MessageFormatter.error("Table wipe operation failed", error instanceof Error ? error : new Error(String(error)), { prefix: "Wipe" });
+            throw error;
+        }
     }
 };

package/dist/cli/commands/functionCommands.js

@@ -111,38 +111,14 @@ export const functionCommands = {
             MessageFormatter.error("Failed to initialize controller or load config", undefined, { prefix: "Functions" });
             return;
         }
-        // Offer choice of function config sources: central YAML, .fnconfig.yaml, or both
-        let sourceChoice = 'both';
+        // Discover per-function .fnconfig.yaml definitions and merge with central list for selection
+        // No global prompt; we'll handle conflicts per-function if both exist.
+        let discovered = [];
+        let central = cli.controller.config.functions || [];
         try {
-            const answer = await inquirer.prompt([
-                {
-                    type: 'list',
-                    name: 'source',
-                    message: 'Select function config source:',
-                    choices: [
-                        { name: 'config.yaml functions (central)', value: 'central' },
-                        { name: '.fnconfig.yaml (discovered per-function)', value: 'fnconfig' },
-                        { name: 'Both (merge; .fnconfig overrides)', value: 'both' },
-                    ],
-                    default: 'both'
-                }
-            ]);
-            sourceChoice = answer.source;
-        }
-        catch { }
-        try {
-            const discovered = discoverFnConfigs(cli.currentDir);
-            const central = cli.controller.config.functions || [];
-            if (sourceChoice === 'central') {
-                cli.controller.config.functions = central;
-            }
-            else if (sourceChoice === 'fnconfig') {
-                cli.controller.config.functions = discovered;
-            }
-            else {
-                const merged = mergeDiscoveredFunctions(central, discovered);
-                cli.controller.config.functions = merged;
-            }
+            discovered = discoverFnConfigs(cli.currentDir);
+            const merged = mergeDiscoveredFunctions(central, discovered);
+            cli.controller.config.functions = merged;
         }
         catch { }
         const functions = await cli.selectFunctions("Select function(s) to deploy:", true, true);
@@ -155,22 +131,51 @@ export const functionCommands = {
                 MessageFormatter.error("Invalid function configuration", undefined, { prefix: "Functions" });
                 return;
             }
+            // Resolve effective config for this function (prefer per-function choice if both sources exist)
+            const byIdOrName = (arr) => arr.find((f) => f?.$id === functionConfig.$id || f?.name === functionConfig.name);
+            const centralDef = byIdOrName(central);
+            const discoveredDef = byIdOrName(discovered);
+            let effectiveConfig = functionConfig;
+            if (centralDef && discoveredDef) {
+                try {
+                    const answer = await inquirer.prompt([
+                        {
+                            type: 'list',
+                            name: 'cfgChoice',
+                            message: `Multiple configs found for '${functionConfig.name}'. Which to use?`,
+                            choices: [
+                                { name: 'config.yaml (central)', value: 'central' },
+                                { name: '.fnconfig.yaml (local file)', value: 'fnconfig' },
+                                { name: 'Merge (.fnconfig overrides central)', value: 'merge' },
+                            ],
+                            default: 'fnconfig'
+                        }
+                    ]);
+                    if (answer.cfgChoice === 'central')
+                        effectiveConfig = centralDef;
+                    else if (answer.cfgChoice === 'fnconfig')
+                        effectiveConfig = discoveredDef;
+                    else
+                        effectiveConfig = { ...centralDef, ...discoveredDef };
+                }
+                catch { }
+            }
             // Ensure functions array exists
             if (!cli.controller.config.functions) {
                 cli.controller.config.functions = [];
             }
-            const functionNameLower = functionConfig.name
+            const functionNameLower = effectiveConfig.name
                 .toLowerCase()
                 .replace(/\s+/g, "-");
             // Debug logging
             MessageFormatter.info(`🔍 Function deployment debug:`, { prefix: "Functions" });
-            MessageFormatter.info(`  Function name: ${functionConfig.name}`, { prefix: "Functions" });
-            MessageFormatter.info(`  Function ID: ${functionConfig.$id}`, { prefix: "Functions" });
-            MessageFormatter.info(`  Config dirPath: ${functionConfig.dirPath || 'undefined'}`, { prefix: "Functions" });
-            if (functionConfig.dirPath) {
-                const expandedPath = functionConfig.dirPath.startsWith('~/')
-                    ? functionConfig.dirPath.replace('~', os.homedir())
-                    : functionConfig.dirPath;
+            MessageFormatter.info(`  Function name: ${effectiveConfig.name}`, { prefix: "Functions" });
+            MessageFormatter.info(`  Function ID: ${effectiveConfig.$id}`, { prefix: "Functions" });
+            MessageFormatter.info(`  Config dirPath: ${effectiveConfig.dirPath || 'undefined'}`, { prefix: "Functions" });
+            if (effectiveConfig.dirPath) {
+                const expandedPath = effectiveConfig.dirPath.startsWith('~/')
+                    ? effectiveConfig.dirPath.replace('~', os.homedir())
+                    : effectiveConfig.dirPath;
                 MessageFormatter.info(`  Expanded dirPath: ${expandedPath}`, { prefix: "Functions" });
             }
             MessageFormatter.info(`  Appwrite folder: ${cli.controller.getAppwriteFolderPath()}`, { prefix: "Functions" });
@@ -182,10 +187,10 @@ export const functionCommands = {
             // Check locations in priority order:
             const priorityLocations = [
                 // 1. Config dirPath if specified (with tilde expansion)
-                functionConfig.dirPath
-                    ? (require('node:path').isAbsolute(expandTildePath(functionConfig.dirPath))
-                        ? expandTildePath(functionConfig.dirPath)
-                        : require('node:path').resolve(yamlBaseDir, expandTildePath(functionConfig.dirPath)))
+                effectiveConfig.dirPath
+                    ? (require('node:path').isAbsolute(expandTildePath(effectiveConfig.dirPath))
+                        ? expandTildePath(effectiveConfig.dirPath)
+                        : require('node:path').resolve(yamlBaseDir, expandTildePath(effectiveConfig.dirPath)))
                     : undefined,
                 // 2. Appwrite config folder/functions/name
                 join(cli.controller.getAppwriteFolderPath(), "functions", functionNameLower),
@@ -226,10 +231,10 @@ export const functionCommands = {
                 if (shouldDownload) {
                     try {
                         MessageFormatter.progress("Downloading latest deployment...", { prefix: "Functions" });
-                        const { path: downloadedPath, function: remoteFunction } = await downloadLatestFunctionDeployment(cli.controller.appwriteServer, functionConfig.$id, join(cli.controller.getAppwriteFolderPath(), "functions"));
+                        const { path: downloadedPath, function: remoteFunction } = await downloadLatestFunctionDeployment(cli.controller.appwriteServer, effectiveConfig.$id, join(cli.controller.getAppwriteFolderPath(), "functions"));
                         MessageFormatter.success(`✨ Function downloaded to ${downloadedPath}`, { prefix: "Functions" });
                         functionPath = downloadedPath;
-                        functionConfig.dirPath = downloadedPath;
+                        effectiveConfig.dirPath = downloadedPath;
                         const existingIndex = cli.controller.config.functions.findIndex((f) => f?.$id === remoteFunction.$id);
                         if (existingIndex >= 0) {
                             cli.controller.config.functions[existingIndex].dirPath =
@@ -243,7 +248,7 @@ export const functionCommands = {
                     }
                 }
                 else {
-                    MessageFormatter.error(`Function ${functionConfig.name} not found locally. Cannot deploy.`, undefined, { prefix: "Functions" });
+                    MessageFormatter.error(`Function ${effectiveConfig.name} not found locally. Cannot deploy.`, undefined, { prefix: "Functions" });
                     return;
                 }
             }
@@ -252,8 +257,8 @@ export const functionCommands = {
                 return;
             }
             try {
-                await deployLocalFunction(cli.controller.appwriteServer, functionConfig.name, {
-                    ...functionConfig,
+                await deployLocalFunction(cli.controller.appwriteServer, effectiveConfig.name, {
+                    ...effectiveConfig,
                     dirPath: functionPath,
                 }, functionPath);
                 MessageFormatter.success("Function deployed successfully!", { prefix: "Functions" });

package/dist/config/ConfigManager.d.ts

@@ -54,6 +54,11 @@ export interface ConfigLoadOptions {
      * Override session authentication (used for preserving session on reload)
      */
     sessionOverride?: SessionAuthInfo;
+    /**
+     * Prefer loading from appwrite.config.json over config.yaml
+     * @default false
+     */
+    preferJson?: boolean;
 }
 /**
  * Filter function for collections (accepts both Collection and CollectionCreate)

package/dist/config/ConfigManager.js

@@ -139,7 +139,7 @@ export class ConfigManager {
         }
         logger.debug("Loading config from file", { prefix: "ConfigManager", options });
         // 2. Discover config file
-        const configPath = this.discoveryService.findConfig(options.configDir || process.cwd());
+        const configPath = await this.discoveryService.findConfig(options.configDir || process.cwd(), options.preferJson || false);
         if (!configPath) {
             const searchDir = options.configDir || process.cwd();
             throw new Error(`No Appwrite configuration found in "${searchDir}".\n` +

package/dist/config/services/ConfigDiscoveryService.d.ts

@@ -10,74 +10,76 @@ export interface DiscoveryResult {
 /**
  * Service for discovering Appwrite configuration files and collection/table definitions.
  *
+ * Uses find-up for intelligent searching with git repository boundary detection:
+ * 1. Finds .git directory to establish repo root boundary
+ * 2. Searches UP from current directory to repo root
+ * 3. Searches DOWN recursively within repo root
+ *
  * Search Priority:
  * 1. YAML configs (.appwrite/config.yaml, .appwrite/config.yml, etc.)
- * 2. TypeScript configs (appwriteConfig.ts)
- * 3. JSON configs (appwrite.json, appwrite.config.json)
- *
- * Features:
- * - Searches up directory tree (max 5 levels)
- * - Ignores common directories (node_modules, .git, etc.)
- * - Discovers both collections/ and tables/ directories
- * - Recursive subdirectory scanning for .appwrite folders
+ * 2. JSON configs (appwrite.config.json, appwrite.json)
+ * 3. TypeScript configs (appwriteConfig.ts)
  */
 export declare class ConfigDiscoveryService {
     /**
      * YAML configuration file names to search for
      */
     private readonly YAML_FILENAMES;
+    /**
+     * JSON configuration file names to search for
+     */
+    private readonly JSON_FILENAMES;
     /**
      * TypeScript configuration file names to search for
      */
     private readonly TS_FILENAMES;
     /**
-     * JSON configuration file names to search for
+     * Finds the git repository root directory
+     * @param startDir The directory to start searching from
+     * @returns Path to the repository root, or startDir if no .git found
      */
-    private readonly JSON_FILENAMES;
+    private findRepoRoot;
     /**
-     * Maximum levels to search up the directory tree
+     * Recursively searches downward for files matching patterns
+     * @param dir Directory to search in
+     * @param patterns File patterns to match
+     * @param maxDepth Maximum depth to search
+     * @param currentDepth Current recursion depth
+     * @returns First matching file path or null
      */
-    private readonly MAX_SEARCH_DEPTH;
+    private searchDownward;
     /**
-     * Finds any configuration file with priority: YAML → TypeScript → JSON
+     * Finds any configuration file with configurable priority
      * @param startDir The directory to start searching from
+     * @param preferJson If true, prioritizes appwrite.config.json over YAML (default: false)
      * @returns Path to the configuration file or null if not found
+     *
+     * Default priority: YAML → JSON → TypeScript
+     * With preferJson=true: JSON → YAML → TypeScript
      */
-    findConfig(startDir: string): string | null;
+    findConfig(startDir: string, preferJson?: boolean): Promise<string | null>;
     /**
      * Finds YAML configuration files
-     * Searches current directory, subdirectories, and parent directory
+     * Searches UP to repo root, then DOWN from repo root
      * @param startDir The directory to start searching from
+     * @param repoRoot The repository root boundary
      * @returns Path to the YAML config file or null if not found
      */
-    findYamlConfig(startDir: string): string | null;
+    findYamlConfig(startDir: string, repoRoot?: string): Promise<string | null>;
     /**
-     * Recursively searches for YAML configs in .appwrite subdirectories
-     * @param dir The directory to search
-     * @param depth Current search depth
-     * @returns Path to YAML config or null
+     * Finds JSON project configuration files (appwrite.config.json, appwrite.json)
+     * @param startDir The directory to start searching from
+     * @param repoRoot The repository root boundary
+     * @returns Path to the JSON config file or null if not found
      */
-    private findYamlConfigRecursive;
+    findProjectConfig(startDir: string, repoRoot?: string): Promise<string | null>;
     /**
      * Finds TypeScript configuration files (appwriteConfig.ts)
      * @param startDir The directory to start searching from
+     * @param repoRoot The repository root boundary
      * @returns Path to the TypeScript config file or null if not found
      */
-    findTypeScriptConfig(startDir: string): string | null;
-    /**
-     * Recursively searches for TypeScript configuration files
-     * @param dir The directory to search
-     * @param depth Current search depth
-     * @returns Path to TypeScript config or null
-     */
-    private findTypeScriptConfigRecursive;
-    /**
-     * Finds project configuration JSON files (appwrite.json, appwrite.config.json)
-     * Searches up to 5 levels up the directory tree
-     * @param startDir The directory to start searching from
-     * @returns Path to the JSON config file or null if not found
-     */
-    findProjectConfig(startDir?: string): string | null;
+    findTypeScriptConfig(startDir: string, repoRoot?: string): Promise<string | null>;
     /**
      * Discovers collection YAML files in a collections/ directory
      * @param collectionsDir Path to the collections directory
@@ -95,32 +97,26 @@ export declare class ConfigDiscoveryService {
      * @param startDir The directory to start searching from
      * @returns Path to .appwrite directory or null if not found
      */
-    findAppwriteDirectory(startDir: string): string | null;
+    findAppwriteDirectory(startDir: string): Promise<string | null>;
     /**
      * Finds the functions directory
      * @param startDir The directory to start searching from
      * @returns Path to functions directory or null if not found
      */
-    findFunctionsDirectory(startDir: string): string | null;
-    /**
-     * Recursively searches for the functions directory
-     * @param dir The directory to search
-     * @param depth Current search depth
-     * @returns Path to functions directory or null
-     */
-    private findFunctionsDirectoryRecursive;
+    findFunctionsDirectory(startDir: string): Promise<string | null>;
     /**
      * Gets a summary of all discoverable configuration files
      * Useful for debugging configuration issues
      * @param startDir The directory to start searching from
      * @returns Object containing paths to all discovered config types
      */
-    getConfigurationSummary(startDir: string): {
+    getConfigurationSummary(startDir: string): Promise<{
         yaml: string | null;
         typescript: string | null;
         json: string | null;
         appwriteDirectory: string | null;
         functionsDirectory: string | null;
         selectedConfig: string | null;
-    };
+        repoRoot: string;
+    }>;
 }