aicm 0.9.1 → 0.11.0

package/README.md

@@ -2,13 +2,14 @@
 
 > Agentic IDE Configuration Manager
 
-A CLI tool for syncing and managing Agentic IDE rules across projects
+A CLI tool for managing Agentic IDE configurations across projects
 
-## Why
+https://github.com/user-attachments/assets/e80dedbc-89c4-4747-9acf-b7ecb7493fcc
 
-With the rise of Agentic IDEs like cursor and windsurf, we have an opportunity to enforce best practices through rules. However, these rules are typically isolated within individual developers or projects.
+## Why
 
-**aicm** is a CLI tool for distributing Agentic IDE configurations, rules, and MCPs across projects. It leverages package managers to copy configurations from node_modules to the correct locations in your file system.
+With the rise of Agentic IDEs, we have an opportunity to enforce best practices through rules. However, these rules are typically isolated within individual projects.
+**aicm** is a CLI tool for distributing Agentic IDE configurations, rules, and MCPs across projects. It leverages node package managers, copy configurations from node_modules to the correct locations in your file system.
 
 ## Getting Started
 
@@ -33,6 +34,11 @@ In your project's `aicm.json`, reference the package and the specific rule:
   "rules": {
     "typescript": "@myteam/ai-tools/rules/typescript.mdc",
     "react": "@myteam/ai-tools/rules/react.mdc"
+  },
+  "mcpServers": {
+    "my-mcp": {
+      "url": "https://example.com/sse"
+    }
   }
 }
 ```
@@ -47,7 +53,7 @@ In your project's `aicm.json`, reference the package and the specific rule:
 }
 ```
 
-Now the rules will be linked to `.cursor/rules/aicm/` when you run `npm install`.
+Now, when you run `npm install`, the rules will be added to `.cursor/rules/aicm/` and the mcps to `.cursor/mcp.json`.
 
 ### Using Presets
 
@@ -147,6 +153,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 +296,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 +342,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

@@ -10,27 +10,25 @@ 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 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");
+const mcp_writer_1 = require("../utils/mcp-writer");
 /**
- * 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
+ * Helper function to execute a function within a specific working directory
+ * and ensure the original directory is always restored
  */
-function writeMcpServersToTargets(mcpServers, ides, cwd) {
-    if (!mcpServers)
-        return;
-    for (const ide of ides) {
-        let mcpPath = null;
-        if (ide === "cursor") {
-            mcpPath = node_path_1.default.join(cwd, ".cursor", "mcp.json");
-            fs_extra_1.default.ensureDirSync(node_path_1.default.dirname(mcpPath));
-        }
-        // Windsurf does not support project mcpServers, so skip
-        if (mcpPath) {
-            fs_extra_1.default.writeJsonSync(mcpPath, { mcpServers }, { spaces: 2 });
+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);
         }
     }
 }
@@ -47,6 +45,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 +111,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 +188,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
@@ -154,39 +201,32 @@ async function install(options = {}) {
         if (config.mcpServers) {
             // Filter out canceled servers
             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);
+            (0, mcp_writer_1.writeMcpServersToTargets)(filteredMcpServers, config.ides, cwd);
         }
         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

@@ -11,11 +11,11 @@ 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 contents
  */
-export declare function loadPreset(presetPath: string): {
+export declare function loadPreset(presetPath: string, cwd?: string): {
     rules: Rules;
     mcpServers?: import("../types").MCPServers;
     presets?: string[];
@@ -24,11 +24,11 @@ export declare function loadPreset(presetPath: 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(): Config | 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
  */
@@ -40,4 +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 declare function saveConfig(config: Config, cwd?: string): boolean;

package/dist/utils/config.js

@@ -14,17 +14,23 @@ 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 it's a local file with .json extension and exists, return as is
-    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)
@@ -33,13 +39,13 @@ function getFullPresetPath(presetPath) {
             const presetPathWithConfig = node_path_1.default.join(presetPath, "aicm.json");
             try {
                 absolutePresetPath = require.resolve(presetPathWithConfig, {
-                    paths: [__dirname, process.cwd()],
+                    paths: [__dirname, workingDir],
                 });
             }
             catch (_a) {
                 // If direct resolution fails, try as a package name
                 absolutePresetPath = require.resolve(presetPath, {
-                    paths: [__dirname, process.cwd()],
+                    paths: [__dirname, workingDir],
                 });
                 // If we found the package but not the config file, look for aicm.json
                 if (fs_extra_1.default.existsSync(absolutePresetPath)) {
@@ -62,8 +68,8 @@ function getFullPresetPath(presetPath) {
 /**
  * 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.`);
     }
@@ -92,7 +98,7 @@ const processedPresets = new Set();
 /**
  * Process presets and return a new config with merged rules and metadata
  */
-function processPresets(config) {
+function processPresets(config, cwd) {
     // Create a deep copy of the config to avoid mutations
     const newConfig = JSON.parse(JSON.stringify(config));
     const metadata = {
@@ -101,17 +107,17 @@ function processPresets(config) {
     };
     // Clear processed presets tracking set when starting from the top level
     processedPresets.clear();
-    return processPresetsInternal(newConfig, metadata);
+    return processPresetsInternal(newConfig, metadata, cwd);
 }
 /**
  * Internal function to process presets recursively
  */
-function processPresetsInternal(config, metadata) {
+function processPresetsInternal(config, metadata, cwd) {
     if (!config.presets || !Array.isArray(config.presets)) {
         return { config, metadata };
     }
     for (const presetPath of config.presets) {
-        const pathInfo = getFullPresetPath(presetPath);
+        const pathInfo = getFullPresetPath(presetPath, cwd);
         if (!pathInfo) {
             throw new Error(`Error loading preset: "${presetPath}". Make sure the package is installed in your project.`);
         }
@@ -122,7 +128,7 @@ function processPresetsInternal(config, metadata) {
         }
         // Mark this preset as processed
         processedPresets.add(pathInfo.fullPath);
-        const preset = loadPreset(presetPath);
+        const preset = loadPreset(presetPath, cwd);
         if (!preset)
             continue;
         // Process nested presets first (depth-first)
@@ -134,7 +140,7 @@ function processPresetsInternal(config, metadata) {
                 ides: [],
             };
             // Recursively process the nested presets
-            const { config: nestedConfig } = processPresetsInternal(presetConfig, metadata);
+            const { config: nestedConfig } = processPresetsInternal(presetConfig, metadata, cwd);
             Object.assign(preset.rules, nestedConfig.rules);
         }
         const { updatedConfig, updatedMetadata } = mergePresetRules(config, preset.rules, pathInfo, metadata);
@@ -200,12 +206,12 @@ function mergePresetMcpServers(configMcpServers, presetMcpServers) {
  * 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;
@@ -222,12 +228,13 @@ 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"`);
     }
-    const { config: processedConfig, metadata } = processPresets(config);
+    const { config: processedConfig, metadata } = processPresets(config, workingDir);
     // Store metadata for later access
     currentMetadata = metadata;
     return processedConfig;
@@ -249,8 +256,9 @@ function getOriginalPresetPath(config, 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/mcp-writer.d.ts

@@ -0,0 +1,14 @@
+import { Config } 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;
+/**
+ * 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;

package/dist/utils/mcp-writer.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeMcpServersToTargets = writeMcpServersToTargets;
+exports.writeMcpServersToFile = writeMcpServersToFile;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const node_path_1 = __importDefault(require("node:path"));
+/**
+ * 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
+ */
+function writeMcpServersToTargets(mcpServers, ides, cwd) {
+    if (!mcpServers)
+        return;
+    for (const ide of ides) {
+        if (ide === "cursor") {
+            const mcpPath = node_path_1.default.join(cwd, ".cursor", "mcp.json");
+            writeMcpServersToFile(mcpServers, mcpPath);
+        }
+        // Windsurf does not support project mcpServers, so skip
+    }
+}
+/**
+ * Write MCP servers configuration to a specific file
+ * @param mcpServers The MCP servers configuration
+ * @param mcpPath The path to the mcp.json file
+ */
+function writeMcpServersToFile(mcpServers, mcpPath) {
+    var _a;
+    if (!mcpServers)
+        return;
+    fs_extra_1.default.ensureDirSync(node_path_1.default.dirname(mcpPath));
+    const existingConfig = fs_extra_1.default.existsSync(mcpPath)
+        ? fs_extra_1.default.readJsonSync(mcpPath)
+        : {};
+    const existingMcpServers = (_a = existingConfig === null || existingConfig === void 0 ? void 0 : existingConfig.mcpServers) !== null && _a !== void 0 ? _a : {};
+    // Filter out any existing aicm-managed servers (with aicm: true)
+    // This removes stale aicm servers that are no longer in the configuration
+    const userMcpServers = {};
+    for (const [key, value] of Object.entries(existingMcpServers)) {
+        if (typeof value === "object" && value !== null && value.aicm !== true) {
+            userMcpServers[key] = value;
+        }
+    }
+    // Mark new aicm servers as managed and filter out canceled servers
+    const aicmMcpServers = {};
+    for (const [key, value] of Object.entries(mcpServers)) {
+        if (value !== false) {
+            aicmMcpServers[key] = {
+                ...value,
+                aicm: true,
+            };
+        }
+    }
+    // Merge user servers with aicm servers (aicm servers override user servers with same key)
+    const mergedMcpServers = {
+        ...userMcpServers,
+        ...aicmMcpServers,
+    };
+    const mergedConfig = {
+        ...existingConfig,
+        mcpServers: mergedMcpServers,
+    };
+    fs_extra_1.default.writeJsonSync(mcpPath, mergedConfig, { spaces: 2 });
+}

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.1",
+  "version": "0.11.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",