aicm 0.9.0 → 0.10.0

package/README.md

@@ -147,6 +147,44 @@ After installation, open Cursor and ask it to do something. Your AI assistant wi
 
 To prevent [prompt-injection](https://en.wikipedia.org/wiki/Prompt_injection), use only packages from trusted sources.
 
+## Workspaces Support
+
+aicm supports workspaces by automatically discovering and installing configurations across multiple packages in your repository.
+
+To enable workspaces mode, use the `--workspaces` flag:
+
+```bash
+npx aicm install --workspaces
+```
+
+This will:
+
+1. **Discover packages**: Automatically find all directories containing `aicm.json` files in your repository
+2. **Install per package**: Install rules and MCPs for each package individually in their respective directories
+
+### How It Works
+
+Each directory containing an `aicm.json` file is treated as a separate package with its own configuration.
+
+For example, in a workspace structure like:
+
+```
+├── packages/
+│   ├── frontend/
+│   │   └── aicm.json
+│   └── backend/
+│       └── aicm.json
+└── services/
+    └── api/
+        └── aicm.json
+```
+
+Running `npx aicm install --workspaces` will install rules for each package in their respective directories:
+
+- `packages/frontend/.cursor/rules/aicm/`
+- `packages/backend/.cursor/rules/aicm/`
+- `services/api/.cursor/rules/aicm/`
+
 ## Configuration
 
 To configure aicm, use either:
@@ -252,6 +290,8 @@ npx aicm install
 Options:
 
 - `--ci`: run in CI environments (default: `false`)
+- `--workspaces`: enable workspaces mode to discover and install configurations across multiple packages
+- `--verbose`: show detailed output during installation
 
 ## Node.js API
 
@@ -296,6 +336,8 @@ Installs rules and MCP servers based on configuration.
 - `cwd`: Base directory to use instead of `process.cwd()`
 - `config`: Custom config object to use instead of loading from file
 - `installOnCI`: Run installation on CI environments (default: `false`)
+- `workspaces`: Enable workspaces mode (default: `false`)
+- `verbose`: Show verbose output during installation (default: `false`)
 
 **Returns:**
 

package/dist/commands/install.d.ts

@@ -15,6 +15,14 @@ export interface InstallOptions {
      * allow installation on CI environments
      */
     installOnCI?: boolean;
+    /**
+     * Enable workspaces mode
+     */
+    workspaces?: boolean;
+    /**
+     * Show verbose output during installation
+     */
+    verbose?: boolean;
 }
 /**
  * Result of the install operation
@@ -32,6 +40,10 @@ export interface InstallResult {
      * Number of rules installed
      */
     installedRuleCount: number;
+    /**
+     * Number of packages installed
+     */
+    packagesCount: number;
 }
 /**
  * Core implementation of the rule installation logic
@@ -39,4 +51,4 @@ export interface InstallResult {
  * @returns Result of the install operation
  */
 export declare function install(options?: InstallOptions): Promise<InstallResult>;
-export declare function installCommand(installOnCI?: boolean): Promise<void>;
+export declare function installCommand(installOnCI?: boolean, workspaces?: boolean, verbose?: boolean): Promise<void>;

package/dist/commands/install.js

@@ -13,6 +13,26 @@ const rule_writer_1 = require("../utils/rule-writer");
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const node_path_1 = __importDefault(require("node:path"));
 const ci_info_1 = require("ci-info");
+const discovery_1 = require("./workspaces/discovery");
+const workspaces_install_1 = require("./workspaces/workspaces-install");
+/**
+ * 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);
+        }
+    }
+}
 /**
  * Write MCP servers configuration to IDE targets
  * @param mcpServers The MCP servers configuration
@@ -47,6 +67,64 @@ 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
@@ -55,45 +133,38 @@ function isInCIEnvironment() {
 async function install(options = {}) {
     const cwd = options.cwd || process.cwd();
     const installOnCI = options.installOnCI === true; // Default to false if not specified
-    try {
-        const originalCwd = process.cwd();
-        if (cwd !== originalCwd) {
-            process.chdir(cwd);
+    return withWorkingDirectory(cwd, async () => {
+        if (options.workspaces) {
+            return await handleWorkspacesInstallation(cwd, installOnCI, options.verbose);
         }
-        const ruleCollection = (0, rule_collector_1.initRuleCollection)();
         const config = options.config || (0, config_1.getConfig)();
+        const ruleCollection = (0, rule_collector_1.initRuleCollection)();
         if (!config) {
-            if (cwd !== originalCwd) {
-                process.chdir(originalCwd);
-            }
             return {
                 success: false,
-                error: "Configuration file not found!",
+                error: "Configuration file not found",
                 installedRuleCount: 0,
+                packagesCount: 0,
             };
         }
         const inCI = isInCIEnvironment();
         if (inCI && !installOnCI && !config.installOnCI) {
-            if (cwd !== originalCwd) {
-                process.chdir(originalCwd);
-            }
             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) {
-                if (cwd !== originalCwd) {
-                    process.chdir(originalCwd);
-                }
                 return {
                     success: false,
-                    error: "No rules defined in configuration.",
+                    error: "No rules defined in configuration",
                     installedRuleCount: 0,
+                    packagesCount: 0,
                 };
             }
         }
@@ -139,13 +210,11 @@ async function install(options = {}) {
         }
         // If there were errors, exit with error
         if (hasErrors) {
-            if (cwd !== originalCwd) {
-                process.chdir(originalCwd);
-            }
             return {
                 success: false,
                 error: errorMessages.join("; "),
                 installedRuleCount,
+                packagesCount: 0,
             };
         }
         // Write all collected rules to their targets
@@ -156,37 +225,30 @@ async function install(options = {}) {
             const filteredMcpServers = Object.fromEntries(Object.entries(config.mcpServers).filter(([, v]) => v !== false));
             writeMcpServersToTargets(filteredMcpServers, config.ides, cwd);
         }
-        // Restore original cwd
-        if (cwd !== originalCwd) {
-            process.chdir(originalCwd);
-        }
         return {
             success: true,
             installedRuleCount,
+            packagesCount: 1,
         };
-    }
-    catch (e) {
-        const errorMessage = e instanceof Error ? e.message : String(e);
-        // If cwd was changed, restore it
-        if (cwd !== process.cwd()) {
-            process.chdir(cwd);
-        }
-        return {
-            success: false,
-            error: errorMessage,
-            installedRuleCount: 0,
-        };
-    }
+    });
 }
-async function installCommand(installOnCI) {
+async function installCommand(installOnCI, workspaces, verbose) {
     try {
-        const result = await install({ installOnCI });
+        const result = await install({ installOnCI, workspaces, verbose });
         if (!result.success) {
             console.error(chalk_1.default.red(result.error));
             process.exit(1);
         }
         else {
-            console.log("Rules installation completed");
+            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");
+            }
         }
     }
     catch (error) {

package/dist/commands/monorepo/discovery.d.ts

@@ -0,0 +1,7 @@
+import { PackageInfo } from "../../types";
+/**
+ * Discover all packages with aicm configurations in a monorepo
+ * @param rootDir The root directory to search from
+ * @returns Array of discovered packages
+ */
+export declare function discoverPackagesWithAicm(rootDir: string): Promise<PackageInfo[]>;

package/dist/commands/monorepo/discovery.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.discoverPackagesWithAicm = discoverPackagesWithAicm;
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const config_1 = require("../../utils/config");
+/**
+ * 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 in a monorepo
+ * @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));
+}

package/dist/commands/monorepo/installer.d.ts

@@ -0,0 +1,9 @@
+import { PackageInfo, MonorepoInstallResult } from "./types";
+import { InstallOptions } from "../install";
+/**
+ * Install aicm configurations for all packages in a monorepo
+ * @param packages The packages to install configurations for
+ * @param options Install options
+ * @returns Result of the monorepo installation
+ */
+export declare function installMonorepoPackages(packages: PackageInfo[], options?: InstallOptions): Promise<MonorepoInstallResult>;

package/dist/commands/monorepo/installer.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installMonorepoPackages = installMonorepoPackages;
+const chalk_1 = __importDefault(require("chalk"));
+const node_path_1 = __importDefault(require("node:path"));
+const install_1 = require("../install");
+/**
+ * Install aicm configurations for all packages in a monorepo
+ * @param packages The packages to install configurations for
+ * @param options Install options
+ * @returns Result of the monorepo installation
+ */
+async function installMonorepoPackages(packages, options = {}) {
+    console.log(chalk_1.default.blue(`📦 Installing configurations...`));
+    const results = [];
+    let totalRuleCount = 0;
+    // Install packages sequentially for now (can be parallelized later)
+    for (const pkg of packages) {
+        const packagePath = node_path_1.default.resolve(process.cwd(), pkg.path);
+        try {
+            console.log(chalk_1.default.gray(`  Installing ${pkg.path}...`));
+            const result = await (0, install_1.install)({
+                ...options,
+                cwd: packagePath,
+            });
+            if (result.success) {
+                console.log(chalk_1.default.green(`✅ ${pkg.path} (${result.installedRuleCount} rules)`));
+                totalRuleCount += result.installedRuleCount;
+            }
+            else {
+                console.log(chalk_1.default.red(`❌ ${pkg.path}: ${result.error}`));
+            }
+            results.push({
+                path: pkg.path,
+                success: result.success,
+                error: result.error,
+                installedRuleCount: result.installedRuleCount,
+            });
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.log(chalk_1.default.red(`❌ ${pkg.path}: ${errorMessage}`));
+            results.push({
+                path: pkg.path,
+                success: false,
+                error: errorMessage,
+                installedRuleCount: 0,
+            });
+        }
+    }
+    const successfulPackages = results.filter((r) => r.success);
+    const failedPackages = results.filter((r) => !r.success);
+    // Print summary
+    if (failedPackages.length > 0) {
+        console.log(chalk_1.default.yellow(`\n⚠️  Installation completed with errors`));
+        console.log(chalk_1.default.green(`Successfully installed: ${successfulPackages.length}/${packages.length} packages (${totalRuleCount} rules total)`));
+        console.log(chalk_1.default.red(`Failed packages: ${failedPackages.map((p) => p.path).join(", ")}`));
+    }
+    else {
+        console.log(chalk_1.default.green(`\n🎉 Successfully installed ${totalRuleCount} rules across ${packages.length} packages`));
+    }
+    return {
+        success: failedPackages.length === 0,
+        packages: results,
+        totalRuleCount,
+    };
+}

package/dist/commands/monorepo/monorepo-install.d.ts

@@ -0,0 +1,9 @@
+import { PackageInfo, MonorepoInstallResult } from "../../types";
+import { InstallOptions } from "../install";
+/**
+ * Install aicm configurations for all packages in a monorepo
+ * @param packages The packages to install configurations for
+ * @param options Install options
+ * @returns Result of the monorepo installation
+ */
+export declare function installMonorepoPackages(packages: PackageInfo[], options?: InstallOptions): Promise<MonorepoInstallResult>;

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

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installMonorepoPackages = installMonorepoPackages;
+const install_1 = require("../install");
+/**
+ * Install aicm configurations for all packages in a monorepo
+ * @param packages The packages to install configurations for
+ * @param options Install options
+ * @returns Result of the monorepo installation
+ */
+async function installMonorepoPackages(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_1.install)({
+                ...options,
+                cwd: packagePath,
+            });
+            totalRuleCount += result.installedRuleCount;
+            results.push({
+                path: pkg.relativePath,
+                success: result.success,
+                error: result.error,
+                installedRuleCount: result.installedRuleCount,
+            });
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            results.push({
+                path: pkg.relativePath,
+                success: false,
+                error: errorMessage,
+                installedRuleCount: 0,
+            });
+        }
+    }
+    const failedPackages = results.filter((r) => !r.success);
+    return {
+        success: failedPackages.length === 0,
+        packages: results,
+        totalRuleCount,
+    };
+}

package/dist/commands/monorepo/types.d.ts

@@ -0,0 +1 @@
+export * from "../../types";

package/dist/commands/monorepo/types.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("../../types"), exports);

package/dist/commands/workspaces/discovery.d.ts

@@ -0,0 +1,7 @@
+import { PackageInfo } from "../../types";
+/**
+ * Discover all packages with aicm configurations
+ * @param rootDir The root directory to search from
+ * @returns Array of discovered packages
+ */
+export declare function discoverPackagesWithAicm(rootDir: string): Promise<PackageInfo[]>;

package/dist/commands/workspaces/discovery.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.discoverPackagesWithAicm = discoverPackagesWithAicm;
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const config_1 = require("../../utils/config");
+/**
+ * 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));
+}

package/dist/commands/workspaces/workspaces-install.d.ts

@@ -0,0 +1,9 @@
+import { PackageInfo, WorkspacesInstallResult } from "../../types";
+import { InstallOptions } from "../install";
+/**
+ * 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
+ */
+export declare function installWorkspacesPackages(packages: PackageInfo[], options?: InstallOptions): Promise<WorkspacesInstallResult>;

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

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installWorkspacesPackages = installWorkspacesPackages;
+const install_1 = require("../install");
+/**
+ * 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_1.install)({
+                ...options,
+                cwd: packagePath,
+            });
+            totalRuleCount += result.installedRuleCount;
+            results.push({
+                path: pkg.relativePath,
+                success: result.success,
+                error: result.error,
+                installedRuleCount: result.installedRuleCount,
+            });
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            results.push({
+                path: pkg.relativePath,
+                success: false,
+                error: errorMessage,
+                installedRuleCount: 0,
+            });
+        }
+    }
+    const failedPackages = results.filter((r) => !r.success);
+    return {
+        success: failedPackages.length === 0,
+        packages: results,
+        totalRuleCount,
+    };
+}

package/dist/index.js

@@ -17,6 +17,8 @@ const args = (0, arg_1.default)({
     "--help": Boolean,
     "--version": Boolean,
     "--ci": Boolean,
+    "--workspaces": Boolean,
+    "--verbose": Boolean,
     "-h": "--help",
     "-v": "--version",
 }, {
@@ -36,7 +38,7 @@ switch (command) {
         (0, init_1.initCommand)();
         break;
     case "install":
-        (0, install_1.installCommand)(args["--ci"]);
+        (0, install_1.installCommand)(args["--ci"], args["--workspaces"], args["--verbose"]);
         break;
     case "list":
         (0, list_1.listCommand)();
@@ -62,10 +64,13 @@ ${chalk_1.default.bold("OPTIONS")}
   -h, --help          Show this help message
   -v, --version       Show version number
   --ci                Run in CI environments (default: \`false\`)
+  --workspaces        Install rules across all workspaces
+  --verbose           Show detailed output during installation
 
 ${chalk_1.default.bold("EXAMPLES")}
   $ aicm init
   $ aicm install
+  $ aicm install --workspaces
   $ aicm list
 `);
 }

package/dist/types/index.d.ts

@@ -41,3 +41,18 @@ export interface RuleCollection {
     cursor: RuleContent[];
     windsurf: RuleContent[];
 }
+export interface PackageInfo {
+    relativePath: string;
+    absolutePath: string;
+    config: Config;
+}
+export interface WorkspacesInstallResult {
+    success: boolean;
+    packages: Array<{
+        path: string;
+        success: boolean;
+        error?: string;
+        installedRuleCount: number;
+    }>;
+    totalRuleCount: number;
+}

package/dist/utils/config.d.ts

@@ -1,29 +1,34 @@
 import { Config, Rules } from "../types";
-interface ConfigWithMeta extends Config {
-    __ruleSources?: Record<string, string>;
-    __originalPresetPaths?: Record<string, string>;
+export interface RuleMetadata {
+    ruleSources: Record<string, string>;
+    originalPresetPaths: Record<string, string>;
+}
+export interface ConfigResult {
+    config: Config;
+    metadata: RuleMetadata;
 }
 export interface PresetPathInfo {
     fullPath: string;
     originalPath: string;
 }
-export declare function getFullPresetPath(presetPath: string): PresetPathInfo | null;
+export declare function getFullPresetPath(presetPath: string, cwd?: string): PresetPathInfo | null;
 /**
- * Load a preset file and return its rules and mcpServers
+ * Load a preset file and return its contents
  */
-export declare function loadPreset(presetPath: string): {
+export declare function loadPreset(presetPath: string, cwd?: string): {
     rules: Rules;
     mcpServers?: import("../types").MCPServers;
+    presets?: string[];
 } | null;
 /**
  * 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(): ConfigWithMeta | null;
+export declare function loadAicmConfigCosmiconfig(searchFrom?: string): Config | null;
 /**
  * Get the configuration from aicm.json or package.json (using cosmiconfigSync) and merge with any presets
  */
-export declare function getConfig(): Config | null;
+export declare function getConfig(cwd?: string): Config | null;
 /**
  * Get the source preset path for a rule if it came from a preset
  */
@@ -35,5 +40,4 @@ export declare function getOriginalPresetPath(config: Config, ruleName: string):
 /**
  * Save the configuration to the aicm.json file
  */
-export declare function saveConfig(config: Config): boolean;
-export {};
+export declare function saveConfig(config: Config, cwd?: string): boolean;

package/dist/utils/config.js

@@ -14,36 +14,62 @@ 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 getFullPresetPath(presetPath) {
-    if (presetPath.endsWith(".json") && fs_extra_1.default.pathExistsSync(presetPath)) {
-        return { fullPath: presetPath, originalPath: presetPath };
+function getFullPresetPath(presetPath, cwd) {
+    const workingDir = cwd || process.cwd();
+    // If it's a local file with .json extension, check relative to the working directory
+    if (presetPath.endsWith(".json")) {
+        const absolutePath = node_path_1.default.isAbsolute(presetPath)
+            ? presetPath
+            : node_path_1.default.resolve(workingDir, presetPath);
+        if (fs_extra_1.default.pathExistsSync(absolutePath)) {
+            return { fullPath: absolutePath, originalPath: presetPath };
+        }
     }
     try {
         let absolutePresetPath;
+        // Handle npm package with explicit JSON path
         if (presetPath.endsWith(".json")) {
             absolutePresetPath = require.resolve(presetPath, {
-                paths: [__dirname, process.cwd()],
+                paths: [__dirname, workingDir],
             });
         }
+        // Handle npm package without explicit JSON path (add aicm.json)
         else {
+            // For npm packages, ensure we properly handle scoped packages (@org/pkg)
             const presetPathWithConfig = node_path_1.default.join(presetPath, "aicm.json");
-            absolutePresetPath = require.resolve(presetPathWithConfig, {
-                paths: [__dirname, process.cwd()],
-            });
+            try {
+                absolutePresetPath = require.resolve(presetPathWithConfig, {
+                    paths: [__dirname, workingDir],
+                });
+            }
+            catch (_a) {
+                // If direct resolution fails, try as a package name
+                absolutePresetPath = require.resolve(presetPath, {
+                    paths: [__dirname, workingDir],
+                });
+                // If we found the package but not the config file, look for aicm.json
+                if (fs_extra_1.default.existsSync(absolutePresetPath)) {
+                    const packageDir = node_path_1.default.dirname(absolutePresetPath);
+                    const configPath = node_path_1.default.join(packageDir, "aicm.json");
+                    if (fs_extra_1.default.existsSync(configPath)) {
+                        absolutePresetPath = configPath;
+                    }
+                }
+            }
         }
         return fs_extra_1.default.existsSync(absolutePresetPath)
             ? { fullPath: absolutePresetPath, originalPath: presetPath }
             : null;
     }
-    catch (_a) {
+    catch (_b) {
         return null;
     }
 }
 /**
- * Load a preset file and return its rules and mcpServers
+ * Load a preset file and return its contents
  */
-function loadPreset(presetPath) {
-    const pathInfo = getFullPresetPath(presetPath);
+function loadPreset(presetPath, cwd) {
+    const pathInfo = getFullPresetPath(presetPath, cwd);
     if (!pathInfo) {
         throw new Error(`Error loading preset: "${presetPath}". Make sure the package is installed in your project.`);
     }
@@ -59,82 +85,133 @@ function loadPreset(presetPath) {
     if (!preset.rules || typeof preset.rules !== "object") {
         throw new Error(`Error loading preset: Invalid format in ${presetPath} - missing or invalid 'rules' object`);
     }
-    return { rules: preset.rules, mcpServers: preset.mcpServers };
+    return {
+        rules: preset.rules,
+        mcpServers: preset.mcpServers,
+        presets: preset.presets,
+    };
+}
+// Global metadata storage
+let currentMetadata = null;
+// Track processed presets to avoid circular references
+const processedPresets = new Set();
+/**
+ * Process presets and return a new config with merged rules and metadata
+ */
+function processPresets(config, cwd) {
+    // Create a deep copy of the config to avoid mutations
+    const newConfig = JSON.parse(JSON.stringify(config));
+    const metadata = {
+        ruleSources: {},
+        originalPresetPaths: {},
+    };
+    // Clear processed presets tracking set when starting from the top level
+    processedPresets.clear();
+    return processPresetsInternal(newConfig, metadata, cwd);
 }
 /**
- * Process presets and merge their rules and mcpServers into the config
+ * Internal function to process presets recursively
  */
-function processPresets(config) {
+function processPresetsInternal(config, metadata, cwd) {
     if (!config.presets || !Array.isArray(config.presets)) {
-        return;
+        return { config, metadata };
     }
     for (const presetPath of config.presets) {
-        const preset = loadPreset(presetPath);
-        if (!preset)
+        const pathInfo = getFullPresetPath(presetPath, cwd);
+        if (!pathInfo) {
+            throw new Error(`Error loading preset: "${presetPath}". Make sure the package is installed in your project.`);
+        }
+        // Skip if we've already processed this preset (prevents circular references)
+        if (processedPresets.has(pathInfo.fullPath)) {
+            console.warn(`Skipping already processed preset: ${presetPath}`);
             continue;
-        const pathInfo = getFullPresetPath(presetPath);
-        if (!pathInfo)
+        }
+        // Mark this preset as processed
+        processedPresets.add(pathInfo.fullPath);
+        const preset = loadPreset(presetPath, cwd);
+        if (!preset)
             continue;
-        mergePresetRules(config, preset.rules, pathInfo);
+        // Process nested presets first (depth-first)
+        if (preset.presets && preset.presets.length > 0) {
+            // Create a temporary config with just the presets from this preset
+            const presetConfig = {
+                rules: {},
+                presets: preset.presets,
+                ides: [],
+            };
+            // Recursively process the nested presets
+            const { config: nestedConfig } = processPresetsInternal(presetConfig, metadata, cwd);
+            Object.assign(preset.rules, nestedConfig.rules);
+        }
+        const { updatedConfig, updatedMetadata } = mergePresetRules(config, preset.rules, pathInfo, metadata);
+        Object.assign(config.rules, updatedConfig.rules);
+        Object.assign(metadata.ruleSources, updatedMetadata.ruleSources);
+        Object.assign(metadata.originalPresetPaths, updatedMetadata.originalPresetPaths);
         if (preset.mcpServers) {
-            mergePresetMcpServers(config, preset.mcpServers);
+            config.mcpServers = mergePresetMcpServers(config.mcpServers || {}, preset.mcpServers);
         }
     }
+    return { config, metadata };
 }
 /**
- * Merge preset rules into the config
+ * Merge preset rules into the config without mutation
  */
-function mergePresetRules(config, presetRules, pathInfo) {
+function mergePresetRules(config, presetRules, pathInfo, metadata) {
+    const updatedRules = { ...config.rules };
+    const updatedMetadata = {
+        ruleSources: { ...metadata.ruleSources },
+        originalPresetPaths: { ...metadata.originalPresetPaths },
+    };
     for (const [ruleName, rulePath] of Object.entries(presetRules)) {
         // Cancel if set to false in config
         if (Object.prototype.hasOwnProperty.call(config.rules, ruleName) &&
             config.rules[ruleName] === false) {
-            delete config.rules[ruleName];
-            if (config.__ruleSources)
-                delete config.__ruleSources[ruleName];
-            if (config.__originalPresetPaths)
-                delete config.__originalPresetPaths[ruleName];
+            delete updatedRules[ruleName];
+            delete updatedMetadata.ruleSources[ruleName];
+            delete updatedMetadata.originalPresetPaths[ruleName];
             continue;
         }
         // Only add if not already defined in config (override handled by config)
         if (!Object.prototype.hasOwnProperty.call(config.rules, ruleName)) {
-            config.rules[ruleName] = rulePath;
-            config.__ruleSources = config.__ruleSources || {};
-            config.__ruleSources[ruleName] = pathInfo.fullPath;
-            config.__originalPresetPaths = config.__originalPresetPaths || {};
-            config.__originalPresetPaths[ruleName] = pathInfo.originalPath;
+            updatedRules[ruleName] = rulePath;
+            updatedMetadata.ruleSources[ruleName] = pathInfo.fullPath;
+            updatedMetadata.originalPresetPaths[ruleName] = pathInfo.originalPath;
         }
     }
+    return {
+        updatedConfig: { ...config, rules: updatedRules },
+        updatedMetadata,
+    };
 }
 /**
- * Merge preset mcpServers into the config
+ * Merge preset mcpServers without mutation
  */
-function mergePresetMcpServers(config, presetMcpServers) {
-    if (!config.mcpServers)
-        config.mcpServers = {};
+function mergePresetMcpServers(configMcpServers, presetMcpServers) {
+    const newMcpServers = { ...configMcpServers };
     for (const [serverName, serverConfig] of Object.entries(presetMcpServers)) {
         // Cancel if set to false in config
-        if (Object.prototype.hasOwnProperty.call(config.mcpServers, serverName) &&
-            config.mcpServers[serverName] === false) {
-            delete config.mcpServers[serverName];
+        if (Object.prototype.hasOwnProperty.call(newMcpServers, serverName) &&
+            newMcpServers[serverName] === false) {
+            delete newMcpServers[serverName];
             continue;
         }
         // Only add if not already defined in config (override handled by config)
-        if (!Object.prototype.hasOwnProperty.call(config.mcpServers, serverName)) {
-            config.mcpServers[serverName] = serverConfig;
+        if (!Object.prototype.hasOwnProperty.call(newMcpServers, serverName)) {
+            newMcpServers[serverName] = serverConfig;
         }
     }
+    return newMcpServers;
 }
 /**
  * Load the aicm config using cosmiconfigSync, supporting both aicm.json and package.json.
  * Returns the config object or null if not found.
  */
-function loadAicmConfigCosmiconfig() {
+function loadAicmConfigCosmiconfig(searchFrom) {
     const explorer = (0, cosmiconfig_1.cosmiconfigSync)("aicm", {
         searchPlaces: ["package.json", "aicm.json"],
     });
     try {
-        const result = explorer.search();
+        const result = explorer.search(searchFrom);
         if (!result || !result.config)
             return null;
         const config = result.config;
@@ -151,33 +228,37 @@ function loadAicmConfigCosmiconfig() {
 /**
  * Get the configuration from aicm.json or package.json (using cosmiconfigSync) and merge with any presets
  */
-function getConfig() {
-    const config = loadAicmConfigCosmiconfig();
+function getConfig(cwd) {
+    const workingDir = cwd || process.cwd();
+    const config = loadAicmConfigCosmiconfig(workingDir);
     if (!config) {
-        throw new Error(`No config found in ${process.cwd()}, create one using "aicm init"`);
+        throw new Error(`No config found in ${workingDir}, create one using "aicm init"`);
     }
-    processPresets(config);
-    return config;
+    const { config: processedConfig, metadata } = processPresets(config, workingDir);
+    // Store metadata for later access
+    currentMetadata = metadata;
+    return processedConfig;
 }
 /**
  * Get the source preset path for a rule if it came from a preset
  */
 function getRuleSource(config, ruleName) {
     var _a;
-    return (_a = config.__ruleSources) === null || _a === void 0 ? void 0 : _a[ruleName];
+    return (_a = currentMetadata === null || currentMetadata === void 0 ? void 0 : currentMetadata.ruleSources) === null || _a === void 0 ? void 0 : _a[ruleName];
 }
 /**
  * Get the original preset path for a rule if it came from a preset
  */
 function getOriginalPresetPath(config, ruleName) {
     var _a;
-    return (_a = config.__originalPresetPaths) === null || _a === void 0 ? void 0 : _a[ruleName];
+    return (_a = currentMetadata === null || currentMetadata === void 0 ? void 0 : currentMetadata.originalPresetPaths) === null || _a === void 0 ? void 0 : _a[ruleName];
 }
 /**
  * Save the configuration to the aicm.json file
  */
-function saveConfig(config) {
-    const configPath = node_path_1.default.join(process.cwd(), CONFIG_FILE);
+function saveConfig(config, cwd) {
+    const workingDir = cwd || process.cwd();
+    const configPath = node_path_1.default.join(workingDir, CONFIG_FILE);
     try {
         fs_extra_1.default.writeJsonSync(configPath, config, { spaces: 2 });
         return true;

package/dist/utils/package-detector.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Detect the type of package based on files present in the directory
+ * @param packageDir The directory to check
+ * @returns The detected package type
+ */
+export declare function detectPackageType(packageDir: string): "npm" | "bazel" | "unknown";

package/dist/utils/package-detector.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectPackageType = detectPackageType;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const node_path_1 = __importDefault(require("node:path"));
+/**
+ * Detect the type of package based on files present in the directory
+ * @param packageDir The directory to check
+ * @returns The detected package type
+ */
+function detectPackageType(packageDir) {
+    // Check for npm package
+    if (fs_extra_1.default.existsSync(node_path_1.default.join(packageDir, "package.json"))) {
+        return "npm";
+    }
+    // Check for Bazel package
+    if (fs_extra_1.default.existsSync(node_path_1.default.join(packageDir, "BUILD")) ||
+        fs_extra_1.default.existsSync(node_path_1.default.join(packageDir, "BUILD.bazel"))) {
+        return "bazel";
+    }
+    return "unknown";
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aicm",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "A TypeScript CLI tool for managing AI IDE rules across different projects and teams",
   "main": "dist/api.js",
   "types": "dist/api.d.ts",