aicm 0.17.3 → 0.18.0

package/README.md

@@ -215,6 +215,17 @@ When installed, `aicm` will automatically rewrite the link to point to the corre
 
 > **Note:** Path rewriting works for any relative path format in your commands - markdown links, inline code references, or bare paths - as long as they point to actual files in your `rulesDir`.
 
+#### usage in workspaces mode
+
+When using workspaces, commands installed at the monorepo root need to access auxiliary files located in nested packages (e.g., `packages/frontend/rules/helper.js`).
+
+`aicm` handles this automatically by:
+
+1. Copying referenced auxiliary files from nested packages to the root `.cursor/rules/aicm/` directory
+2. Rewriting paths in the root command to point to these copied files
+
+**Warning:** If your command references a `.mdc` file (Cursor rule), `aicm` will check if it's a "manual" rule or an "automatic" rule (one that is always applied or auto-attached via globs). If it's an automatic rule, `aicm` will warn you that copying it to the root might cause the rule to be included twice in the context (once from the nested package and once from the root copy). For best results, only reference manual `.mdc` files or other file types (like `.js`, `.json`, `.md`) from commands.
+
 ### Overrides
 
 You can disable or replace specific rules or commands provided by presets using the `overrides` field:
@@ -271,6 +282,12 @@ Running `npx aicm install` will install rules for each package in their respecti
 - `packages/backend/.cursor/rules/aicm/`
 - `services/api/.cursor/rules/aicm/`
 
+**Why install in both places?**
+`aicm` installs configurations at both the package level AND the root level to support different workflows:
+
+- **Package-level context:** When a developer opens a specific package folder (e.g., `packages/frontend`) in their IDE, they get the specific rules, commands, and MCP servers for that package.
+- **Root-level context:** When a developer opens the monorepo root, `aicm` ensures they have access to all commands and MCP servers from all packages via the merged root configuration. While rules are typically read from nested directories by Cursor, commands and MCP servers must be configured at the root to be accessible.
+
 ### Preset Packages in Workspaces
 
 When you have a preset package within your workspace (a package that provides rules to be consumed by others), you can prevent aicm from installing rules into it by setting `skipInstall: true`:

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

@@ -0,0 +1,5 @@
+import { InstallResult } from "./install";
+/**
+ * Install rules across multiple packages in a workspace
+ */
+export declare function installWorkspaces(cwd: string, installOnCI: boolean, verbose?: boolean, dryRun?: boolean): Promise<InstallResult>;

package/dist/commands/install-workspaces.js

@@ -0,0 +1,367 @@
+"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 chalk_1 = __importDefault(require("chalk"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const node_path_1 = __importDefault(require("node:path"));
+const working_directory_1 = require("../utils/working-directory");
+const rules_file_writer_1 = require("../utils/rules-file-writer");
+const workspace_discovery_1 = require("../utils/workspace-discovery");
+const install_1 = require("./install");
+/**
+ * Extract .mdc file references from a command for warning purposes
+ * Returns absolute paths to .mdc files that are referenced
+ */
+function extractMdcReferences(content, commandSourcePath) {
+    const commandDir = node_path_1.default.dirname(commandSourcePath);
+    const mdcFiles = [];
+    const seenPaths = new Set();
+    // Same regex pattern as rewriteCommandRelativeLinks
+    const matches = content.matchAll(/\.\.[/\\][\w\-/\\.]+/g);
+    for (const match of matches) {
+        const relativePath = match[0];
+        const resolved = node_path_1.default.normalize(node_path_1.default.resolve(commandDir, relativePath));
+        // Only process .mdc files that exist
+        if (resolved.endsWith(".mdc") &&
+            !seenPaths.has(resolved) &&
+            fs_extra_1.default.existsSync(resolved) &&
+            fs_extra_1.default.statSync(resolved).isFile()) {
+            seenPaths.add(resolved);
+            mdcFiles.push(resolved);
+        }
+    }
+    return mdcFiles;
+}
+/**
+ * Check if a .mdc file is a manual rule (not automatic/auto-attached/agent-requested)
+ */
+function isManualRule(content) {
+    const metadata = (0, rules_file_writer_1.parseRuleFrontmatter)(content);
+    // Check for always rules
+    if (metadata.type === "always" ||
+        metadata.alwaysApply === true ||
+        metadata.alwaysApply === "true") {
+        return false;
+    }
+    // Check for auto-attached rules
+    if (metadata.type === "auto-attached" || metadata.globs) {
+        return false;
+    }
+    // Check for agent-requested rules
+    if (metadata.type === "agent-requested" || metadata.description) {
+        return false;
+    }
+    // Default to manual rule
+    return true;
+}
+/**
+ * Process .mdc files referenced by commands in workspace mode
+ * Warns about non-manual rules and copies them to root for command access
+ */
+function processMdcFilesForWorkspace(mdcFilePaths, commands, packages, rootDir) {
+    const mdcAssets = [];
+    // Build a map of command source paths to their preset names
+    const commandPresetMap = new Map();
+    for (const command of commands) {
+        const commandDir = node_path_1.default.dirname(command.sourcePath);
+        commandPresetMap.set(commandDir, command.presetName);
+    }
+    for (const mdcPath of mdcFilePaths) {
+        const content = fs_extra_1.default.readFileSync(mdcPath, "utf8");
+        if (!isManualRule(content)) {
+            const relativePath = node_path_1.default.basename(mdcPath);
+            console.warn(chalk_1.default.yellow(`Warning: Command references non-manual rule file "${relativePath}". ` +
+                `This may cause the rule to be included twice in the context. ` +
+                `Consider using manual rules (without alwaysApply, globs, or description metadata) ` +
+                `when referencing from commands.`));
+        }
+        // Find which command references this .mdc file and get its preset name
+        let mdcAssetName = "";
+        let presetName;
+        let found = false;
+        // First check packages for local files
+        for (const pkg of packages) {
+            const rulesDir = pkg.config.config.rulesDir;
+            if (rulesDir) {
+                const pkgRulesPath = node_path_1.default.join(pkg.absolutePath, rulesDir);
+                if (mdcPath.startsWith(pkgRulesPath)) {
+                    mdcAssetName = node_path_1.default.relative(pkgRulesPath, mdcPath);
+                    found = true;
+                    break;
+                }
+            }
+        }
+        // If not found in local packages, it might be from a preset
+        if (!found) {
+            // Find the command that references this .mdc file
+            for (const command of commands) {
+                if (command.presetName) {
+                    const commandDir = node_path_1.default.dirname(command.sourcePath);
+                    const rulesDir = node_path_1.default.join(node_path_1.default.dirname(commandDir), "rules");
+                    if (mdcPath.startsWith(rulesDir)) {
+                        mdcAssetName = node_path_1.default.relative(rulesDir, mdcPath);
+                        presetName = command.presetName;
+                        found = true;
+                        break;
+                    }
+                }
+            }
+        }
+        if (found) {
+            // Build the final asset name with preset namespace if applicable
+            const finalAssetName = presetName
+                ? node_path_1.default.posix.join(...(0, install_1.extractNamespaceFromPresetPath)(presetName), mdcAssetName.replace(/\\/g, "/"))
+                : mdcAssetName.replace(/\\/g, "/");
+            // Create an AssetFile entry for the .mdc file
+            mdcAssets.push({
+                name: finalAssetName,
+                content: Buffer.from(content),
+                sourcePath: mdcPath,
+                source: presetName ? "preset" : "local",
+                presetName,
+            });
+            // Copy to root .cursor/rules/aicm/
+            const cursorRulesDir = node_path_1.default.join(rootDir, ".cursor", "rules", "aicm");
+            const targetPath = node_path_1.default.join(cursorRulesDir, finalAssetName);
+            fs_extra_1.default.ensureDirSync(node_path_1.default.dirname(targetPath));
+            fs_extra_1.default.writeFileSync(targetPath, content);
+        }
+    }
+    return mdcAssets;
+}
+function mergeWorkspaceCommands(packages) {
+    var _a;
+    const commands = [];
+    const seenPresetCommands = new Set();
+    for (const pkg of packages) {
+        const hasCursorTarget = pkg.config.config.targets.includes("cursor");
+        if (!hasCursorTarget) {
+            continue;
+        }
+        for (const command of (_a = pkg.config.commands) !== null && _a !== void 0 ? _a : []) {
+            if (command.presetName) {
+                const presetKey = `${command.presetName}::${command.name}`;
+                if (seenPresetCommands.has(presetKey)) {
+                    continue;
+                }
+                seenPresetCommands.add(presetKey);
+            }
+            commands.push(command);
+        }
+    }
+    return commands;
+}
+function collectWorkspaceCommandTargets(packages) {
+    const targets = new Set();
+    for (const pkg of packages) {
+        if (pkg.config.config.targets.includes("cursor")) {
+            targets.add("cursor");
+        }
+    }
+    return Array.from(targets);
+}
+function mergeWorkspaceMcpServers(packages) {
+    const merged = {};
+    const info = {};
+    for (const pkg of packages) {
+        for (const [key, value] of Object.entries(pkg.config.mcpServers)) {
+            if (value === false)
+                continue;
+            const json = JSON.stringify(value);
+            if (!info[key]) {
+                info[key] = {
+                    configs: new Set([json]),
+                    packages: [pkg.relativePath],
+                    chosen: pkg.relativePath,
+                };
+            }
+            else {
+                info[key].packages.push(pkg.relativePath);
+                info[key].configs.add(json);
+                info[key].chosen = pkg.relativePath;
+            }
+            merged[key] = value;
+        }
+    }
+    const conflicts = [];
+    for (const [key, data] of Object.entries(info)) {
+        if (data.configs.size > 1) {
+            conflicts.push({ key, packages: data.packages, chosen: data.chosen });
+        }
+    }
+    return { merged, conflicts };
+}
+/**
+ * Install aicm configurations for all packages in a workspace
+ */
+async function installWorkspacesPackages(packages, options = {}) {
+    const results = [];
+    let totalRuleCount = 0;
+    let totalCommandCount = 0;
+    let totalAssetCount = 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.installPackage)({
+                ...options,
+                cwd: packagePath,
+                config: pkg.config,
+            });
+            totalRuleCount += result.installedRuleCount;
+            totalCommandCount += result.installedCommandCount;
+            totalAssetCount += result.installedAssetCount;
+            results.push({
+                path: pkg.relativePath,
+                success: result.success,
+                error: result.error,
+                installedRuleCount: result.installedRuleCount,
+                installedCommandCount: result.installedCommandCount,
+                installedAssetCount: result.installedAssetCount,
+            });
+        }
+        catch (error) {
+            results.push({
+                path: pkg.relativePath,
+                success: false,
+                error: error instanceof Error ? error : new Error(String(error)),
+                installedRuleCount: 0,
+                installedCommandCount: 0,
+                installedAssetCount: 0,
+            });
+        }
+    }
+    const failedPackages = results.filter((r) => !r.success);
+    return {
+        success: failedPackages.length === 0,
+        packages: results,
+        totalRuleCount,
+        totalCommandCount,
+        totalAssetCount,
+    };
+}
+/**
+ * Install rules across multiple packages in a workspace
+ */
+async function installWorkspaces(cwd, installOnCI, verbose = false, dryRun = false) {
+    return (0, working_directory_1.withWorkingDirectory)(cwd, async () => {
+        if (verbose) {
+            console.log(chalk_1.default.blue("🔍 Discovering packages..."));
+        }
+        const allPackages = await (0, workspace_discovery_1.discoverPackagesWithAicm)(cwd);
+        const packages = allPackages.filter((pkg) => {
+            if (pkg.config.config.skipInstall === true) {
+                return false;
+            }
+            const isRoot = pkg.relativePath === ".";
+            if (!isRoot)
+                return true;
+            // For root directories, only keep if it has rules, commands, or presets
+            const hasRules = pkg.config.rules && pkg.config.rules.length > 0;
+            const hasCommands = pkg.config.commands && pkg.config.commands.length > 0;
+            const hasPresets = pkg.config.config.presets && pkg.config.config.presets.length > 0;
+            return hasRules || hasCommands || hasPresets;
+        });
+        if (packages.length === 0) {
+            return {
+                success: false,
+                error: new Error("No packages with aicm configurations found"),
+                installedRuleCount: 0,
+                installedCommandCount: 0,
+                installedAssetCount: 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,
+            verbose,
+            dryRun,
+        });
+        const workspaceCommands = mergeWorkspaceCommands(packages);
+        const workspaceCommandTargets = collectWorkspaceCommandTargets(packages);
+        if (workspaceCommands.length > 0) {
+            (0, install_1.warnPresetCommandCollisions)(workspaceCommands);
+        }
+        if (!dryRun &&
+            workspaceCommands.length > 0 &&
+            workspaceCommandTargets.length > 0) {
+            const dedupedWorkspaceCommands = (0, install_1.dedupeCommandsForInstall)(workspaceCommands);
+            // Collect all assets from packages for command path rewriting
+            const allAssets = packages.flatMap((pkg) => { var _a; return (_a = pkg.config.assets) !== null && _a !== void 0 ? _a : []; });
+            // Copy assets to root so root commands can reference them
+            (0, install_1.writeAssetsToTargets)(allAssets, workspaceCommandTargets);
+            // Extract and process .mdc file references from commands
+            const mdcFilesSet = new Set();
+            for (const command of dedupedWorkspaceCommands) {
+                const mdcRefs = extractMdcReferences(command.content, command.sourcePath);
+                mdcRefs.forEach((ref) => mdcFilesSet.add(ref));
+            }
+            const mdcAssets = processMdcFilesForWorkspace(mdcFilesSet, dedupedWorkspaceCommands, packages, cwd);
+            // Merge .mdc assets with regular assets for link rewriting
+            const allAssetsWithMdc = [...allAssets, ...mdcAssets];
+            (0, install_1.writeCommandsToTargets)(dedupedWorkspaceCommands, allAssetsWithMdc, workspaceCommandTargets);
+        }
+        const { merged: rootMcp, conflicts } = mergeWorkspaceMcpServers(packages);
+        const hasCursorTarget = packages.some((p) => p.config.config.targets.includes("cursor"));
+        if (!dryRun && hasCursorTarget && Object.keys(rootMcp).length > 0) {
+            const mcpPath = node_path_1.default.join(cwd, ".cursor", "mcp.json");
+            (0, install_1.writeMcpServersToFile)(rootMcp, mcpPath);
+        }
+        for (const conflict of conflicts) {
+            console.warn(`Warning: MCP configuration conflict detected\n  Key: "${conflict.key}"\n  Packages: ${conflict.packages.join(", ")}\n  Using configuration from: ${conflict.chosen}`);
+        }
+        if (verbose) {
+            result.packages.forEach((pkg) => {
+                if (pkg.success) {
+                    const summaryParts = [`${pkg.installedRuleCount} rules`];
+                    if (pkg.installedCommandCount > 0) {
+                        summaryParts.push(`${pkg.installedCommandCount} command${pkg.installedCommandCount === 1 ? "" : "s"}`);
+                    }
+                    console.log(chalk_1.default.green(`✅ ${pkg.path} (${summaryParts.join(", ")})`));
+                }
+                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) {
+                const commandSummary = result.totalCommandCount > 0
+                    ? `, ${result.totalCommandCount} command${result.totalCommandCount === 1 ? "" : "s"} total`
+                    : "";
+                console.log(chalk_1.default.green(`Successfully installed: ${result.packages.length - failedPackages.length}/${result.packages.length} packages (${result.totalRuleCount} rule${result.totalRuleCount === 1 ? "" : "s"} total${commandSummary})`));
+                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: new Error(`Package installation failed for ${failedPackages.length} package(s): ${errorDetails}`),
+                installedRuleCount: result.totalRuleCount,
+                installedCommandCount: result.totalCommandCount,
+                installedAssetCount: result.totalAssetCount,
+                packagesCount: result.packages.length,
+            };
+        }
+        return {
+            success: true,
+            installedRuleCount: result.totalRuleCount,
+            installedCommandCount: result.totalCommandCount,
+            installedAssetCount: result.totalAssetCount,
+            packagesCount: result.packages.length,
+        };
+    });
+}

package/dist/commands/install.d.ts

@@ -1,4 +1,4 @@
-import { ResolvedConfig } from "../utils/config";
+import { ResolvedConfig, CommandFile, AssetFile, MCPServers, SupportedTarget } from "../utils/config";
 export interface InstallOptions {
     /**
      * Base directory to use instead of process.cwd()
@@ -50,6 +50,15 @@ export interface InstallResult {
      */
     packagesCount: number;
 }
+export declare function extractNamespaceFromPresetPath(presetPath: string): string[];
+export declare function writeAssetsToTargets(assets: AssetFile[], targets: SupportedTarget[]): void;
+export declare function writeCommandsToTargets(commands: CommandFile[], assets: AssetFile[], targets: SupportedTarget[]): void;
+export declare function warnPresetCommandCollisions(commands: CommandFile[]): void;
+export declare function dedupeCommandsForInstall(commands: CommandFile[]): CommandFile[];
+/**
+ * Write MCP servers configuration to a specific file
+ */
+export declare function writeMcpServersToFile(mcpServers: MCPServers, mcpPath: string): void;
 /**
  * Install rules for a single package (used within workspaces and standalone installs)
  */

package/dist/commands/install.js

@@ -3,6 +3,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractNamespaceFromPresetPath = extractNamespaceFromPresetPath;
+exports.writeAssetsToTargets = writeAssetsToTargets;
+exports.writeCommandsToTargets = writeCommandsToTargets;
+exports.warnPresetCommandCollisions = warnPresetCommandCollisions;
+exports.dedupeCommandsForInstall = dedupeCommandsForInstall;
+exports.writeMcpServersToFile = writeMcpServersToFile;
 exports.installPackage = installPackage;
 exports.install = install;
 exports.installCommand = installCommand;
@@ -13,7 +19,7 @@ const config_1 = require("../utils/config");
 const working_directory_1 = require("../utils/working-directory");
 const is_ci_1 = require("../utils/is-ci");
 const rules_file_writer_1 = require("../utils/rules-file-writer");
-const workspace_discovery_1 = require("../utils/workspace-discovery");
+const install_workspaces_1 = require("./install-workspaces");
 function getTargetPaths() {
     const projectDir = process.cwd();
     return {
@@ -62,7 +68,19 @@ function writeCursorCommands(commands, cursorCommandsDir, assets) {
 }
 function rewriteCommandRelativeLinks(content, commandSourcePath, assets) {
     const commandDir = node_path_1.default.dirname(commandSourcePath);
-    const assetMap = new Map(assets.map((a) => [node_path_1.default.normalize(a.sourcePath), a.name]));
+    const assetMap = new Map(assets.map((a) => {
+        let targetPath;
+        if (a.presetName) {
+            const namespace = extractNamespaceFromPresetPath(a.presetName);
+            // Use posix paths for URLs/links (always forward slashes)
+            targetPath = node_path_1.default.posix.join(...namespace, a.name);
+        }
+        else {
+            // Normalize to posix for consistent forward slashes in links
+            targetPath = a.name.split(node_path_1.default.sep).join(node_path_1.default.posix.sep);
+        }
+        return [node_path_1.default.normalize(a.sourcePath), targetPath];
+    }));
     return content.replace(/\.\.[/\\][\w\-/\\.]+/g, (match) => {
         const resolved = node_path_1.default.normalize(node_path_1.default.resolve(commandDir, match));
         return assetMap.has(resolved)
@@ -227,37 +245,6 @@ function dedupeCommandsForInstall(commands) {
     }
     return Array.from(unique.values());
 }
-function mergeWorkspaceCommands(packages) {
-    var _a;
-    const commands = [];
-    const seenPresetCommands = new Set();
-    for (const pkg of packages) {
-        const hasCursorTarget = pkg.config.config.targets.includes("cursor");
-        if (!hasCursorTarget) {
-            continue;
-        }
-        for (const command of (_a = pkg.config.commands) !== null && _a !== void 0 ? _a : []) {
-            if (command.presetName) {
-                const presetKey = `${command.presetName}::${command.name}`;
-                if (seenPresetCommands.has(presetKey)) {
-                    continue;
-                }
-                seenPresetCommands.add(presetKey);
-            }
-            commands.push(command);
-        }
-    }
-    return commands;
-}
-function collectWorkspaceCommandTargets(packages) {
-    const targets = new Set();
-    for (const pkg of packages) {
-        if (pkg.config.config.targets.includes("cursor")) {
-            targets.add("cursor");
-        }
-    }
-    return Array.from(targets);
-}
 /**
  * Write MCP servers configuration to IDE targets
  */
@@ -311,37 +298,6 @@ function writeMcpServersToFile(mcpServers, mcpPath) {
     };
     fs_extra_1.default.writeJsonSync(mcpPath, mergedConfig, { spaces: 2 });
 }
-function mergeWorkspaceMcpServers(packages) {
-    const merged = {};
-    const info = {};
-    for (const pkg of packages) {
-        for (const [key, value] of Object.entries(pkg.config.mcpServers)) {
-            if (value === false)
-                continue;
-            const json = JSON.stringify(value);
-            if (!info[key]) {
-                info[key] = {
-                    configs: new Set([json]),
-                    packages: [pkg.relativePath],
-                    chosen: pkg.relativePath,
-                };
-            }
-            else {
-                info[key].packages.push(pkg.relativePath);
-                info[key].configs.add(json);
-                info[key].chosen = pkg.relativePath;
-            }
-            merged[key] = value;
-        }
-    }
-    const conflicts = [];
-    for (const [key, data] of Object.entries(info)) {
-        if (data.configs.size > 1) {
-            conflicts.push({ key, packages: data.packages, chosen: data.chosen });
-        }
-    }
-    return { merged, conflicts };
-}
 /**
  * Install rules for a single package (used within workspaces and standalone installs)
  */
@@ -407,166 +363,6 @@ async function installPackage(options = {}) {
         }
     });
 }
-/**
- * Install aicm configurations for all packages in a workspace
- */
-async function installWorkspacesPackages(packages, options = {}) {
-    const results = [];
-    let totalRuleCount = 0;
-    let totalCommandCount = 0;
-    let totalAssetCount = 0;
-    // Install packages sequentially for now (can be parallelized later)
-    for (const pkg of packages) {
-        const packagePath = pkg.absolutePath;
-        try {
-            const result = await installPackage({
-                ...options,
-                cwd: packagePath,
-                config: pkg.config,
-            });
-            totalRuleCount += result.installedRuleCount;
-            totalCommandCount += result.installedCommandCount;
-            totalAssetCount += result.installedAssetCount;
-            results.push({
-                path: pkg.relativePath,
-                success: result.success,
-                error: result.error,
-                installedRuleCount: result.installedRuleCount,
-                installedCommandCount: result.installedCommandCount,
-                installedAssetCount: result.installedAssetCount,
-            });
-        }
-        catch (error) {
-            results.push({
-                path: pkg.relativePath,
-                success: false,
-                error: error instanceof Error ? error : new Error(String(error)),
-                installedRuleCount: 0,
-                installedCommandCount: 0,
-                installedAssetCount: 0,
-            });
-        }
-    }
-    const failedPackages = results.filter((r) => !r.success);
-    return {
-        success: failedPackages.length === 0,
-        packages: results,
-        totalRuleCount,
-        totalCommandCount,
-        totalAssetCount,
-    };
-}
-/**
- * Install rules across multiple packages in a workspace
- */
-async function installWorkspaces(cwd, installOnCI, verbose = false, dryRun = false) {
-    return (0, working_directory_1.withWorkingDirectory)(cwd, async () => {
-        if (verbose) {
-            console.log(chalk_1.default.blue("🔍 Discovering packages..."));
-        }
-        const allPackages = await (0, workspace_discovery_1.discoverPackagesWithAicm)(cwd);
-        const packages = allPackages.filter((pkg) => {
-            if (pkg.config.config.skipInstall === true) {
-                return false;
-            }
-            const isRoot = pkg.relativePath === ".";
-            if (!isRoot)
-                return true;
-            // For root directories, only keep if it has rules, commands, or presets
-            const hasRules = pkg.config.rules && pkg.config.rules.length > 0;
-            const hasCommands = pkg.config.commands && pkg.config.commands.length > 0;
-            const hasPresets = pkg.config.config.presets && pkg.config.config.presets.length > 0;
-            return hasRules || hasCommands || hasPresets;
-        });
-        if (packages.length === 0) {
-            return {
-                success: false,
-                error: new Error("No packages with aicm configurations found"),
-                installedRuleCount: 0,
-                installedCommandCount: 0,
-                installedAssetCount: 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,
-            verbose,
-            dryRun,
-        });
-        const workspaceCommands = mergeWorkspaceCommands(packages);
-        const workspaceCommandTargets = collectWorkspaceCommandTargets(packages);
-        if (workspaceCommands.length > 0) {
-            warnPresetCommandCollisions(workspaceCommands);
-        }
-        if (!dryRun &&
-            workspaceCommands.length > 0 &&
-            workspaceCommandTargets.length > 0) {
-            const dedupedWorkspaceCommands = dedupeCommandsForInstall(workspaceCommands);
-            // Collect all assets from packages for command path rewriting
-            const allAssets = packages.flatMap((pkg) => { var _a; return (_a = pkg.config.assets) !== null && _a !== void 0 ? _a : []; });
-            writeCommandsToTargets(dedupedWorkspaceCommands, allAssets, workspaceCommandTargets);
-        }
-        const { merged: rootMcp, conflicts } = mergeWorkspaceMcpServers(packages);
-        const hasCursorTarget = packages.some((p) => p.config.config.targets.includes("cursor"));
-        if (!dryRun && hasCursorTarget && Object.keys(rootMcp).length > 0) {
-            const mcpPath = node_path_1.default.join(cwd, ".cursor", "mcp.json");
-            writeMcpServersToFile(rootMcp, mcpPath);
-        }
-        for (const conflict of conflicts) {
-            console.warn(`Warning: MCP configuration conflict detected\n  Key: "${conflict.key}"\n  Packages: ${conflict.packages.join(", ")}\n  Using configuration from: ${conflict.chosen}`);
-        }
-        if (verbose) {
-            result.packages.forEach((pkg) => {
-                if (pkg.success) {
-                    const summaryParts = [`${pkg.installedRuleCount} rules`];
-                    if (pkg.installedCommandCount > 0) {
-                        summaryParts.push(`${pkg.installedCommandCount} command${pkg.installedCommandCount === 1 ? "" : "s"}`);
-                    }
-                    console.log(chalk_1.default.green(`✅ ${pkg.path} (${summaryParts.join(", ")})`));
-                }
-                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) {
-                const commandSummary = result.totalCommandCount > 0
-                    ? `, ${result.totalCommandCount} command${result.totalCommandCount === 1 ? "" : "s"} total`
-                    : "";
-                console.log(chalk_1.default.green(`Successfully installed: ${result.packages.length - failedPackages.length}/${result.packages.length} packages (${result.totalRuleCount} rule${result.totalRuleCount === 1 ? "" : "s"} total${commandSummary})`));
-                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: new Error(`Package installation failed for ${failedPackages.length} package(s): ${errorDetails}`),
-                installedRuleCount: result.totalRuleCount,
-                installedCommandCount: result.totalCommandCount,
-                installedAssetCount: result.totalAssetCount,
-                packagesCount: result.packages.length,
-            };
-        }
-        return {
-            success: true,
-            installedRuleCount: result.totalRuleCount,
-            installedCommandCount: result.totalCommandCount,
-            installedAssetCount: result.totalAssetCount,
-            packagesCount: result.packages.length,
-        };
-    });
-}
 /**
  * Core implementation of the rule installation logic
  */
@@ -595,7 +391,7 @@ async function install(options = {}) {
         const shouldUseWorkspaces = (resolvedConfig === null || resolvedConfig === void 0 ? void 0 : resolvedConfig.config.workspaces) ||
             (!resolvedConfig && (0, config_1.detectWorkspacesFromPackageJson)(cwd));
         if (shouldUseWorkspaces) {
-            return await installWorkspaces(cwd, installOnCI, options.verbose, options.dryRun);
+            return await (0, install_workspaces_1.installWorkspaces)(cwd, installOnCI, options.verbose, options.dryRun);
         }
         return installPackage(options);
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aicm",
-  "version": "0.17.3",
+  "version": "0.18.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",
@@ -63,6 +63,6 @@
     "format:check": "prettier --check .",
     "lint": "eslint",
     "version": "auto-changelog -p && git add CHANGELOG.md",
-    "release": "np"
+    "release": "np --no-tests"
   }
 }