aicm 0.12.2 → 0.13.1

package/dist/commands/install/install-workspaces.js

@@ -0,0 +1,172 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installWorkspaces = installWorkspaces;
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const chalk_1 = __importDefault(require("chalk"));
+const config_1 = require("../../utils/config");
+const working_directory_1 = require("../../utils/working-directory");
+const install_package_1 = require("./install-package");
+/**
+ * Discover aicm.json files using git ls-files
+ * @param rootDir The root directory to search from
+ * @returns Array of aicm.json file paths
+ */
+function findAicmFiles(rootDir) {
+    const output = (0, node_child_process_1.execSync)("git ls-files --cached --others --exclude-standard aicm.json **/aicm.json", {
+        cwd: rootDir,
+        encoding: "utf8",
+    });
+    return output
+        .trim()
+        .split("\n")
+        .filter(Boolean)
+        .map((file) => node_path_1.default.resolve(rootDir, file));
+}
+/**
+ * Discover all packages with aicm configurations
+ * @param rootDir The root directory to search from
+ * @returns Array of discovered packages
+ */
+async function discoverPackagesWithAicm(rootDir) {
+    const aicmFiles = findAicmFiles(rootDir);
+    const packages = [];
+    for (const aicmFile of aicmFiles) {
+        const packageDir = node_path_1.default.dirname(aicmFile);
+        const relativePath = node_path_1.default.relative(rootDir, packageDir);
+        // Normalize to forward slashes for cross-platform compatibility
+        const normalizedRelativePath = relativePath.replace(/\\/g, "/");
+        const config = await (0, config_1.getConfig)(packageDir);
+        if (config) {
+            packages.push({
+                relativePath: normalizedRelativePath || ".",
+                absolutePath: packageDir,
+                config,
+            });
+        }
+    }
+    // Sort packages by relativePath for deterministic order
+    return packages.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+}
+/**
+ * Install aicm configurations for all packages in a workspace
+ * @param packages The packages to install configurations for
+ * @param options Install options
+ * @returns Result of the workspace installation
+ */
+async function installWorkspacesPackages(packages, options = {}) {
+    const results = [];
+    let totalRuleCount = 0;
+    // Install packages sequentially for now (can be parallelized later)
+    for (const pkg of packages) {
+        const packagePath = pkg.absolutePath;
+        try {
+            const result = await (0, install_package_1.installPackage)({
+                ...options,
+                cwd: packagePath,
+            });
+            totalRuleCount += result.installedRuleCount;
+            results.push({
+                path: pkg.relativePath,
+                success: result.success,
+                error: result.error,
+                errorStack: result.errorStack,
+                installedRuleCount: result.installedRuleCount,
+            });
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            results.push({
+                path: pkg.relativePath,
+                success: false,
+                error: errorMessage,
+                errorStack: error instanceof Error ? error.stack : undefined,
+                installedRuleCount: 0,
+            });
+        }
+    }
+    const failedPackages = results.filter((r) => !r.success);
+    return {
+        success: failedPackages.length === 0,
+        packages: results,
+        totalRuleCount,
+    };
+}
+/**
+ * Install rules across multiple packages in a workspace
+ * @param cwd The current working directory
+ * @param installOnCI Whether to install on CI environments
+ * @param verbose Whether to show verbose output
+ * @returns Result of the install operation
+ */
+async function installWorkspaces(cwd, installOnCI, verbose = false) {
+    return (0, working_directory_1.withWorkingDirectory)(cwd, async () => {
+        if (verbose) {
+            console.log(chalk_1.default.blue("🔍 Discovering packages..."));
+        }
+        const allPackages = await discoverPackagesWithAicm(cwd);
+        const packages = allPackages.filter((pkg) => {
+            const isRoot = pkg.relativePath === ".";
+            if (!isRoot)
+                return true;
+            // For root directories, only keep if it has rules or presets
+            const hasRules = pkg.config.rules && Object.keys(pkg.config.rules).length > 0;
+            const hasPresets = pkg.config.presets && pkg.config.presets.length > 0;
+            return hasRules || hasPresets;
+        });
+        if (packages.length === 0) {
+            return {
+                success: false,
+                error: "No packages with aicm configurations found",
+                installedRuleCount: 0,
+                packagesCount: 0,
+            };
+        }
+        if (verbose) {
+            console.log(chalk_1.default.blue(`Found ${packages.length} packages with aicm configurations:`));
+            packages.forEach((pkg) => {
+                console.log(chalk_1.default.gray(`  - ${pkg.relativePath}`));
+            });
+            console.log(chalk_1.default.blue(`📦 Installing configurations...`));
+        }
+        const result = await installWorkspacesPackages(packages, {
+            installOnCI,
+        });
+        if (verbose) {
+            result.packages.forEach((pkg) => {
+                if (pkg.success) {
+                    console.log(chalk_1.default.green(`✅ ${pkg.path} (${pkg.installedRuleCount} rules)`));
+                }
+                else {
+                    console.log(chalk_1.default.red(`❌ ${pkg.path}: ${pkg.error}`));
+                }
+            });
+        }
+        const failedPackages = result.packages.filter((r) => !r.success);
+        if (failedPackages.length > 0) {
+            console.log(chalk_1.default.yellow(`Installation completed with errors`));
+            if (verbose) {
+                console.log(chalk_1.default.green(`Successfully installed: ${result.packages.length - failedPackages.length}/${result.packages.length} packages (${result.totalRuleCount} rules total)`));
+                console.log(chalk_1.default.red(`Failed packages: ${failedPackages.map((p) => p.path).join(", ")}`));
+            }
+            const errorDetails = failedPackages
+                .map((p) => `${p.path}: ${p.error}`)
+                .join("; ");
+            return {
+                success: false,
+                error: `Package installation failed for ${failedPackages.length} package(s): ${errorDetails}`,
+                installedRuleCount: result.totalRuleCount,
+                packagesCount: result.packages.length,
+            };
+        }
+        console.log(`Successfully installed ${result.totalRuleCount} rules across ${result.packages.length} packages`);
+        return {
+            success: true,
+            installedRuleCount: result.totalRuleCount,
+            packagesCount: result.packages.length,
+        };
+    });
+}

package/dist/commands/install.d.ts

@@ -1,54 +1,8 @@
-import { NormalizedConfig } from "../types";
-/**
- * Options for the installCore function
- */
-export interface InstallOptions {
-    /**
-     * Base directory to use instead of process.cwd()
-     */
-    cwd?: string;
-    /**
-     * Custom config object to use instead of loading from file
-     */
-    config?: NormalizedConfig;
-    /**
-     * allow installation on CI environments
-     */
-    installOnCI?: boolean;
-    /**
-     * Enable workspaces mode
-     */
-    workspaces?: boolean;
-    /**
-     * Show verbose output during installation
-     */
-    verbose?: boolean;
-}
-/**
- * Result of the install operation
- */
-export interface InstallResult {
-    /**
-     * Whether the operation was successful
-     */
-    success: boolean;
-    /**
-     * Error message if the operation failed
-     */
-    error?: string;
-    /**
-     * Number of rules installed
-     */
-    installedRuleCount: number;
-    /**
-     * Number of packages installed
-     */
-    packagesCount: number;
-}
+import { InstallOptions, InstallResult } from "./install/install-package";
 /**
  * Core implementation of the rule installation logic
  * @param options Install options
  * @returns Result of the install operation
  */
 export declare function install(options?: InstallOptions): Promise<InstallResult>;
-export declare function installCommand(installOnCI?: boolean, workspaces?: boolean, verbose?: boolean): Promise<void>;
+export declare function installCommand(installOnCI?: boolean, verbose?: boolean): Promise<void>;

package/dist/commands/install.js

@@ -7,32 +7,10 @@ exports.install = install;
 exports.installCommand = installCommand;
 const chalk_1 = __importDefault(require("chalk"));
 const config_1 = require("../utils/config");
-const rule_detector_1 = require("../utils/rule-detector");
-const rule_collector_1 = require("../utils/rule-collector");
-const rule_writer_1 = require("../utils/rule-writer");
 const ci_info_1 = require("ci-info");
-const discovery_1 = require("./workspaces/discovery");
-const workspaces_install_1 = require("./workspaces/workspaces-install");
-const mcp_writer_1 = require("../utils/mcp-writer");
-const glob_handler_1 = require("../utils/glob-handler");
-/**
- * Helper function to execute a function within a specific working directory
- * and ensure the original directory is always restored
- */
-async function withWorkingDirectory(targetDir, fn) {
-    const originalCwd = process.cwd();
-    if (targetDir !== originalCwd) {
-        process.chdir(targetDir);
-    }
-    try {
-        return await fn();
-    }
-    finally {
-        if (targetDir !== originalCwd) {
-            process.chdir(originalCwd);
-        }
-    }
-}
+const working_directory_1 = require("../utils/working-directory");
+const install_package_1 = require("./install/install-package");
+const install_workspaces_1 = require("./install/install-workspaces");
 /**
  * Checks if the current environment is a CI environment
  * This function respects any explicit settings in process.env.CI
@@ -46,64 +24,6 @@ function isInCIEnvironment() {
     // Fall back to ci-info's detection
     return ci_info_1.isCI;
 }
-async function handleWorkspacesInstallation(cwd, installOnCI, verbose = false) {
-    return withWorkingDirectory(cwd, async () => {
-        if (verbose) {
-            console.log(chalk_1.default.blue("🔍 Discovering packages..."));
-        }
-        const packages = await (0, discovery_1.discoverPackagesWithAicm)(cwd);
-        if (packages.length === 0) {
-            return {
-                success: false,
-                error: "No packages with aicm configurations found",
-                installedRuleCount: 0,
-                packagesCount: 0,
-            };
-        }
-        if (verbose) {
-            console.log(chalk_1.default.blue(`Found ${packages.length} packages with aicm configurations:`));
-            packages.forEach((pkg) => {
-                console.log(chalk_1.default.gray(`  - ${pkg.relativePath}`));
-            });
-            console.log(chalk_1.default.blue(`📦 Installing configurations...`));
-        }
-        const result = await (0, workspaces_install_1.installWorkspacesPackages)(packages, {
-            installOnCI,
-        });
-        if (verbose) {
-            result.packages.forEach((pkg) => {
-                if (pkg.success) {
-                    console.log(chalk_1.default.green(`✅ ${pkg.path} (${pkg.installedRuleCount} rules)`));
-                }
-                else {
-                    console.log(chalk_1.default.red(`❌ ${pkg.path}: ${pkg.error}`));
-                }
-            });
-        }
-        const failedPackages = result.packages.filter((r) => !r.success);
-        if (failedPackages.length > 0) {
-            console.log(chalk_1.default.yellow(`Installation completed with errors`));
-            if (verbose) {
-                console.log(chalk_1.default.green(`Successfully installed: ${result.packages.length - failedPackages.length}/${result.packages.length} packages (${result.totalRuleCount} rules total)`));
-                console.log(chalk_1.default.red(`Failed packages: ${failedPackages.map((p) => p.path).join(", ")}`));
-            }
-            const errorDetails = failedPackages
-                .map((p) => `${p.path}: ${p.error}`)
-                .join("; ");
-            return {
-                success: false,
-                error: `Package installation failed for ${failedPackages.length} package(s): ${errorDetails}`,
-                installedRuleCount: result.totalRuleCount,
-                packagesCount: result.packages.length,
-            };
-        }
-        return {
-            success: true,
-            installedRuleCount: result.totalRuleCount,
-            packagesCount: result.packages.length,
-        };
-    });
-}
 /**
  * Core implementation of the rule installation logic
  * @param options Install options
@@ -112,132 +32,38 @@ async function handleWorkspacesInstallation(cwd, installOnCI, verbose = false) {
 async function install(options = {}) {
     const cwd = options.cwd || process.cwd();
     const installOnCI = options.installOnCI === true; // Default to false if not specified
-    return withWorkingDirectory(cwd, async () => {
-        if (options.workspaces) {
-            return await handleWorkspacesInstallation(cwd, installOnCI, options.verbose);
-        }
-        const config = options.config || (0, config_1.getConfig)();
-        const ruleCollection = (0, rule_collector_1.initRuleCollection)();
-        if (!config) {
-            return {
-                success: false,
-                error: "Configuration file not found",
-                installedRuleCount: 0,
-                packagesCount: 0,
-            };
-        }
-        const inCI = isInCIEnvironment();
-        if (inCI && !installOnCI && !config.installOnCI) {
-            console.log(chalk_1.default.yellow("Detected CI environment, skipping install."));
-            return {
-                success: true,
-                installedRuleCount: 0,
-                packagesCount: 0,
-            };
-        }
-        // Check if rules are defined (either directly or through presets)
-        if (!config.rules || Object.keys(config.rules).length === 0) {
-            // If there are no presets defined either, show a message
-            if (!config.presets || config.presets.length === 0) {
-                return {
-                    success: false,
-                    error: "No rules defined in configuration",
-                    installedRuleCount: 0,
-                    packagesCount: 0,
-                };
-            }
-        }
-        let expandedRules;
-        try {
-            const expansion = await (0, glob_handler_1.expandRulesGlobPatterns)(config.rules, cwd);
-            expandedRules = expansion.expandedRules;
-            if (options.verbose) {
-                for (const [expandedKey, originalPattern] of Object.entries(expansion.globSources)) {
-                    console.log(chalk_1.default.gray(`  Pattern "${originalPattern}" → ${expandedKey}`));
-                }
-            }
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: `Error expanding glob patterns: ${error instanceof Error ? error.message : String(error)}`,
-                installedRuleCount: 0,
-                packagesCount: 0,
-            };
-        }
-        let hasErrors = false;
-        const errorMessages = [];
-        let installedRuleCount = 0;
-        for (const [name, source] of Object.entries(expandedRules)) {
-            const ruleType = (0, rule_detector_1.detectRuleType)(source);
-            const ruleBasePath = (0, config_1.getRuleSource)(config, name);
-            const originalPresetPath = (0, config_1.getOriginalPresetPath)(config, name);
-            try {
-                let ruleContent;
-                switch (ruleType) {
-                    case "npm":
-                        ruleContent = (0, rule_collector_1.collectNpmRule)(name, source);
-                        break;
-                    case "local":
-                        ruleContent = (0, rule_collector_1.collectLocalRule)(name, source, ruleBasePath);
-                        break;
-                    default:
-                        errorMessages.push(`Unknown rule type: ${ruleType}`);
-                        continue;
-                }
-                if (originalPresetPath) {
-                    ruleContent.presetPath = originalPresetPath;
-                }
-                (0, rule_collector_1.addRuleToCollection)(ruleCollection, ruleContent, config.ides);
-                installedRuleCount++;
-            }
-            catch (e) {
-                hasErrors = true;
-                const errorMessage = `Error processing rule ${name}: ${e instanceof Error ? e.message : String(e)}`;
-                errorMessages.push(errorMessage);
-            }
-        }
-        if (hasErrors) {
-            return {
-                success: false,
-                error: errorMessages.join("; "),
-                installedRuleCount,
-                packagesCount: 0,
-            };
-        }
-        (0, rule_writer_1.writeRulesToTargets)(ruleCollection);
-        if (config.mcpServers) {
-            const filteredMcpServers = Object.fromEntries(Object.entries(config.mcpServers).filter(([, v]) => v !== false));
-            (0, mcp_writer_1.writeMcpServersToTargets)(filteredMcpServers, config.ides, cwd);
-        }
+    const inCI = isInCIEnvironment();
+    if (inCI && !installOnCI) {
+        console.log(chalk_1.default.yellow("Detected CI environment, skipping install."));
         return {
             success: true,
-            installedRuleCount,
-            packagesCount: 1,
+            installedRuleCount: 0,
+            packagesCount: 0,
         };
+    }
+    return (0, working_directory_1.withWorkingDirectory)(cwd, async () => {
+        const config = options.config || (await (0, config_1.getConfig)());
+        if (config === null || config === void 0 ? void 0 : config.workspaces) {
+            return await (0, install_workspaces_1.installWorkspaces)(cwd, installOnCI, options.verbose);
+        }
+        return (0, install_package_1.installPackage)(options);
     });
 }
-async function installCommand(installOnCI, workspaces, verbose) {
-    try {
-        const result = await install({ installOnCI, workspaces, verbose });
-        if (!result.success) {
-            console.error(chalk_1.default.red(result.error));
-            process.exit(1);
+async function installCommand(installOnCI, verbose) {
+    const result = await install({ installOnCI, verbose });
+    if (!result.success) {
+        const error = new Error(result.error);
+        if (result.errorStack) {
+            error.stack = result.errorStack;
+        }
+        throw error;
+    }
+    else {
+        if (result.packagesCount > 1) {
+            console.log(`Successfully installed ${result.installedRuleCount} rules across ${result.packagesCount} packages`);
         }
         else {
-            if (result.packagesCount > 1) {
-                console.log(`Successfully installed ${result.installedRuleCount} rules across ${result.packagesCount} packages`);
-            }
-            else if (workspaces) {
-                console.log(`Successfully installed ${result.installedRuleCount} rules across ${result.packagesCount} packages`);
-            }
-            else {
-                console.log("Rules installation completed");
-            }
+            console.log("Rules installation completed");
         }
     }
-    catch (error) {
-        console.error(chalk_1.default.red(error instanceof Error ? error.message : String(error)));
-        process.exit(1);
-    }
 }

package/dist/commands/list.d.ts

@@ -1 +1 @@
-export declare function listCommand(): void;
+export declare function listCommand(): Promise<void>;

package/dist/commands/list.js

@@ -8,8 +8,8 @@ const chalk_1 = __importDefault(require("chalk"));
 const config_1 = require("../utils/config");
 const rule_status_1 = require("../utils/rule-status");
 const rule_detector_1 = require("../utils/rule-detector");
-function listCommand() {
-    const config = (0, config_1.getConfig)();
+async function listCommand() {
+    const config = await (0, config_1.getConfig)();
     if (!config) {
         console.log(chalk_1.default.red("Configuration file not found!"));
         console.log(`Run ${chalk_1.default.blue("npx aicm init")} to create one.`);

package/dist/commands/workspaces/workspaces-install.js

@@ -24,6 +24,7 @@ async function installWorkspacesPackages(packages, options = {}) {
                 path: pkg.relativePath,
                 success: result.success,
                 error: result.error,
+                errorStack: result.errorStack,
                 installedRuleCount: result.installedRuleCount,
             });
         }
@@ -33,6 +34,7 @@ async function installWorkspacesPackages(packages, options = {}) {
                 path: pkg.relativePath,
                 success: false,
                 error: errorMessage,
+                errorStack: error instanceof Error ? error.stack : undefined,
                 installedRuleCount: 0,
             });
         }

package/dist/types/index.d.ts

@@ -21,7 +21,7 @@ export interface Config {
     rules?: Rules | string;
     presets?: string[];
     mcpServers?: MCPServers;
-    installOnCI?: boolean;
+    workspaces?: boolean;
 }
 export interface NormalizedConfig extends Omit<Config, "rules"> {
     ides: string[];
@@ -57,6 +57,7 @@ export interface WorkspacesInstallResult {
         path: string;
         success: boolean;
         error?: string;
+        errorStack?: string;
         installedRuleCount: number;
     }>;
     totalRuleCount: number;

package/dist/utils/config.d.ts

@@ -22,14 +22,14 @@ export declare function loadPreset(presetPath: string, cwd?: string): {
     presets?: string[];
 } | null;
 /**
- * Load the aicm config using cosmiconfigSync, supporting both aicm.json and package.json.
+ * Load the aicm config using cosmiconfig, supporting both aicm.json and package.json.
  * Returns the config object or null if not found.
  */
-export declare function loadAicmConfigCosmiconfig(searchFrom?: string): NormalizedConfig | null;
+export declare function loadAicmConfigCosmiconfig(searchFrom?: string): Promise<NormalizedConfig | null>;
 /**
  * Get the configuration from aicm.json or package.json (using cosmiconfigSync) and merge with any presets
  */
-export declare function getConfig(cwd?: string): NormalizedConfig | null;
+export declare function getConfig(cwd?: string): Promise<NormalizedConfig | null>;
 /**
  * Get the source preset path for a rule if it came from a preset
  */

package/dist/utils/config.js

@@ -14,6 +14,7 @@ exports.saveConfig = saveConfig;
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const node_path_1 = __importDefault(require("node:path"));
 const cosmiconfig_1 = require("cosmiconfig");
+const glob_handler_1 = require("./glob-handler");
 const CONFIG_FILE = "aicm.json";
 function normalizeRules(rules) {
     if (!rules)
@@ -108,7 +109,7 @@ const processedPresets = new Set();
 /**
  * Process presets and return a new config with merged rules and metadata
  */
-function processPresets(config, cwd) {
+async function processPresets(config, cwd) {
     // Create a deep copy of the config to avoid mutations
     const newConfig = JSON.parse(JSON.stringify(config));
     const metadata = {
@@ -117,12 +118,12 @@ function processPresets(config, cwd) {
     };
     // Clear processed presets tracking set when starting from the top level
     processedPresets.clear();
-    return processPresetsInternal(newConfig, metadata, cwd);
+    return await processPresetsInternal(newConfig, metadata, cwd);
 }
 /**
  * Internal function to process presets recursively
  */
-function processPresetsInternal(config, metadata, cwd) {
+async function processPresetsInternal(config, metadata, cwd) {
     if (!config.presets || !Array.isArray(config.presets)) {
         return { config, metadata };
     }
@@ -133,7 +134,7 @@ function processPresetsInternal(config, metadata, cwd) {
         }
         // Skip if we've already processed this preset (prevents circular references)
         if (processedPresets.has(pathInfo.fullPath)) {
-            console.warn(`Skipping already processed preset: ${presetPath}`);
+            // Skip duplicates to prevent circular references
             continue;
         }
         // Mark this preset as processed
@@ -141,6 +142,10 @@ function processPresetsInternal(config, metadata, cwd) {
         const preset = loadPreset(presetPath, cwd);
         if (!preset)
             continue;
+        // Expand glob patterns within the preset using its base directory
+        const presetDir = node_path_1.default.dirname(pathInfo.fullPath);
+        const expansion = await (0, glob_handler_1.expandRulesGlobPatterns)(preset.rules, presetDir);
+        preset.rules = expansion.expandedRules;
         // Process nested presets first (depth-first)
         if (preset.presets && preset.presets.length > 0) {
             // Create a temporary config with just the presets from this preset
@@ -150,7 +155,7 @@ function processPresetsInternal(config, metadata, cwd) {
                 ides: [],
             };
             // Recursively process the nested presets
-            const { config: nestedConfig } = processPresetsInternal(presetConfig, metadata, cwd);
+            const { config: nestedConfig } = await processPresetsInternal(presetConfig, metadata, cwd);
             Object.assign(preset.rules, nestedConfig.rules);
         }
         const { updatedConfig, updatedMetadata } = mergePresetRules(config, preset.rules, pathInfo, metadata);
@@ -213,15 +218,15 @@ function mergePresetMcpServers(configMcpServers, presetMcpServers) {
     return newMcpServers;
 }
 /**
- * Load the aicm config using cosmiconfigSync, supporting both aicm.json and package.json.
+ * Load the aicm config using cosmiconfig, supporting both aicm.json and package.json.
  * Returns the config object or null if not found.
  */
-function loadAicmConfigCosmiconfig(searchFrom) {
-    const explorer = (0, cosmiconfig_1.cosmiconfigSync)("aicm", {
+async function loadAicmConfigCosmiconfig(searchFrom) {
+    const explorer = (0, cosmiconfig_1.cosmiconfig)("aicm", {
         searchPlaces: ["package.json", "aicm.json"],
     });
     try {
-        const result = explorer.search(searchFrom);
+        const result = await explorer.search(searchFrom);
         if (!result || !result.config)
             return null;
         const rawConfig = result.config;
@@ -240,13 +245,13 @@ function loadAicmConfigCosmiconfig(searchFrom) {
 /**
  * Get the configuration from aicm.json or package.json (using cosmiconfigSync) and merge with any presets
  */
-function getConfig(cwd) {
+async function getConfig(cwd) {
     const workingDir = cwd || process.cwd();
-    const config = loadAicmConfigCosmiconfig(workingDir);
+    const config = await loadAicmConfigCosmiconfig(workingDir);
     if (!config) {
         throw new Error(`No config found in ${workingDir}, create one using "aicm init"`);
     }
-    const { config: processedConfig, metadata } = processPresets(config, workingDir);
+    const { config: processedConfig, metadata } = await processPresets(config, workingDir);
     // Store metadata for later access
     currentMetadata = metadata;
     return processedConfig;

package/dist/utils/working-directory.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Helper function to execute a function within a specific working directory
+ * and ensure the original directory is always restored
+ */
+export declare function withWorkingDirectory<T>(targetDir: string, fn: () => Promise<T>): Promise<T>;