aicm 0.12.1 → 0.13.0

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 = (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 { Config } 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?: Config;
-    /**
-     * 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 || (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/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

@@ -17,11 +17,15 @@ export interface MCPServers {
     [serverName: string]: MCPServer;
 }
 export interface Config {
-    ides: string[];
-    rules: Rules;
+    ides?: string[];
+    rules?: Rules | string;
     presets?: string[];
     mcpServers?: MCPServers;
-    installOnCI?: boolean;
+    workspaces?: boolean;
+}
+export interface NormalizedConfig extends Omit<Config, "rules"> {
+    ides: string[];
+    rules: Rules;
 }
 export interface RuleMetadata {
     type?: string;
@@ -45,7 +49,7 @@ export interface RuleCollection {
 export interface PackageInfo {
     relativePath: string;
     absolutePath: string;
-    config: Config;
+    config: NormalizedConfig;
 }
 export interface WorkspacesInstallResult {
     success: boolean;
@@ -53,6 +57,7 @@ export interface WorkspacesInstallResult {
         path: string;
         success: boolean;
         error?: string;
+        errorStack?: string;
         installedRuleCount: number;
     }>;
     totalRuleCount: number;

package/dist/utils/config.d.ts

@@ -1,12 +1,13 @@
-import { Config, Rules } from "../types";
+import { Config, NormalizedConfig, Rules } from "../types";
 export interface RuleMetadata {
     ruleSources: Record<string, string>;
     originalPresetPaths: Record<string, string>;
 }
 export interface ConfigResult {
-    config: Config;
+    config: NormalizedConfig;
     metadata: RuleMetadata;
 }
+export declare function normalizeRules(rules: Rules | string | undefined): Rules;
 export interface PresetPathInfo {
     fullPath: string;
     originalPath: string;
@@ -24,19 +25,19 @@ export declare function loadPreset(presetPath: string, cwd?: string): {
  * Load the aicm config using cosmiconfigSync, supporting both aicm.json and package.json.
  * Returns the config object or null if not found.
  */
-export declare function loadAicmConfigCosmiconfig(searchFrom?: string): Config | null;
+export declare function loadAicmConfigCosmiconfig(searchFrom?: string): NormalizedConfig | null;
 /**
  * Get the configuration from aicm.json or package.json (using cosmiconfigSync) and merge with any presets
  */
-export declare function getConfig(cwd?: string): Config | null;
+export declare function getConfig(cwd?: string): NormalizedConfig | null;
 /**
  * Get the source preset path for a rule if it came from a preset
  */
-export declare function getRuleSource(config: Config, ruleName: string): string | undefined;
+export declare function getRuleSource(config: NormalizedConfig, ruleName: string): string | undefined;
 /**
  * Get the original preset path for a rule if it came from a preset
  */
-export declare function getOriginalPresetPath(config: Config, ruleName: string): string | undefined;
+export declare function getOriginalPresetPath(config: NormalizedConfig, ruleName: string): string | undefined;
 /**
  * Save the configuration to the aicm.json file
  */

package/dist/utils/config.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeRules = normalizeRules;
 exports.getFullPresetPath = getFullPresetPath;
 exports.loadPreset = loadPreset;
 exports.loadAicmConfigCosmiconfig = loadAicmConfigCosmiconfig;
@@ -14,6 +15,14 @@ const fs_extra_1 = __importDefault(require("fs-extra"));
 const node_path_1 = __importDefault(require("node:path"));
 const cosmiconfig_1 = require("cosmiconfig");
 const CONFIG_FILE = "aicm.json";
+function normalizeRules(rules) {
+    if (!rules)
+        return {};
+    if (typeof rules === "string") {
+        return { "/": rules };
+    }
+    return rules;
+}
 function getFullPresetPath(presetPath, cwd) {
     const workingDir = cwd || process.cwd();
     // If it's a local file with .json extension, check relative to the working directory
@@ -82,11 +91,12 @@ function loadPreset(presetPath, cwd) {
         const parseError = error;
         throw new Error(`Error loading preset: Invalid JSON in ${presetPath}: ${parseError.message}`);
     }
-    if (!preset.rules || typeof preset.rules !== "object") {
+    if (!preset.rules) {
         throw new Error(`Error loading preset: Invalid format in ${presetPath} - missing or invalid 'rules' object`);
     }
+    const normalizedRules = normalizeRules(preset.rules);
     return {
-        rules: preset.rules,
+        rules: normalizedRules,
         mcpServers: preset.mcpServers,
         presets: preset.presets,
     };
@@ -123,7 +133,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
@@ -214,11 +224,13 @@ function loadAicmConfigCosmiconfig(searchFrom) {
         const result = explorer.search(searchFrom);
         if (!result || !result.config)
             return null;
-        const config = result.config;
-        if (!config.rules)
-            config.rules = {};
-        if (!config.ides)
-            config.ides = ["cursor"];
+        const rawConfig = result.config;
+        const normalizedRules = normalizeRules(rawConfig.rules);
+        const config = {
+            ...rawConfig,
+            ides: rawConfig.ides || ["cursor"],
+            rules: normalizedRules,
+        };
         return config;
     }
     catch (error) {

package/dist/utils/mcp-writer.d.ts

@@ -1,14 +1,14 @@
-import { Config } from "../types";
+import { NormalizedConfig } from "../types";
 /**
  * Write MCP servers configuration to IDE targets
  * @param mcpServers The MCP servers configuration
  * @param ides The IDEs to write to
  * @param cwd The current working directory
  */
-export declare function writeMcpServersToTargets(mcpServers: Config["mcpServers"], ides: string[], cwd: string): void;
+export declare function writeMcpServersToTargets(mcpServers: NormalizedConfig["mcpServers"], ides: string[], cwd: string): void;
 /**
  * Write MCP servers configuration to a specific file
  * @param mcpServers The MCP servers configuration
  * @param mcpPath The path to the mcp.json file
  */
-export declare function writeMcpServersToFile(mcpServers: Config["mcpServers"], mcpPath: string): void;
+export declare function writeMcpServersToFile(mcpServers: NormalizedConfig["mcpServers"], mcpPath: string): void;

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>;