aicm 0.17.3 → 0.19.0

package/dist/commands/install-workspaces.js

@@ -0,0 +1,276 @@
+"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 node_path_1 = __importDefault(require("node:path"));
+const hooks_1 = require("../utils/hooks");
+const working_directory_1 = require("../utils/working-directory");
+const workspace_discovery_1 = require("../utils/workspace-discovery");
+const install_1 = require("./install");
+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 };
+}
+/**
+ * Merge hooks from multiple workspace packages
+ */
+function mergeWorkspaceHooks(packages) {
+    const allHooksConfigs = [];
+    const allHookFiles = [];
+    for (const pkg of packages) {
+        // Collect hooks configs
+        if (pkg.config.hooks) {
+            allHooksConfigs.push(pkg.config.hooks);
+        }
+        // Collect hook files
+        allHookFiles.push(...pkg.config.hookFiles);
+    }
+    // Merge hooks configs
+    const merged = (0, hooks_1.mergeHooksConfigs)(allHooksConfigs);
+    // Dedupe hook files by basename with MD5 checking
+    const dedupedHookFiles = (0, hooks_1.dedupeHookFiles)(allHookFiles);
+    return { merged, hookFiles: dedupedHookFiles };
+}
+/**
+ * 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;
+    let totalHookCount = 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;
+            totalHookCount += result.installedHookCount;
+            results.push({
+                path: pkg.relativePath,
+                success: result.success,
+                error: result.error,
+                installedRuleCount: result.installedRuleCount,
+                installedCommandCount: result.installedCommandCount,
+                installedAssetCount: result.installedAssetCount,
+                installedHookCount: result.installedHookCount,
+            });
+        }
+        catch (error) {
+            results.push({
+                path: pkg.relativePath,
+                success: false,
+                error: error instanceof Error ? error : new Error(String(error)),
+                installedRuleCount: 0,
+                installedCommandCount: 0,
+                installedAssetCount: 0,
+                installedHookCount: 0,
+            });
+        }
+    }
+    const failedPackages = results.filter((r) => !r.success);
+    return {
+        success: failedPackages.length === 0,
+        packages: results,
+        totalRuleCount,
+        totalCommandCount,
+        totalAssetCount,
+        totalHookCount,
+    };
+}
+/**
+ * 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,
+                installedHookCount: 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
+            const allAssets = packages.flatMap((pkg) => { var _a; return (_a = pkg.config.assets) !== null && _a !== void 0 ? _a : []; });
+            // Copy assets to root
+            (0, install_1.writeAssetsToTargets)(allAssets, workspaceCommandTargets);
+            (0, install_1.writeCommandsToTargets)(dedupedWorkspaceCommands, 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}`);
+        }
+        // Merge and write hooks for workspace
+        const { merged: rootHooks, hookFiles: rootHookFiles } = mergeWorkspaceHooks(packages);
+        const hasHooks = rootHooks.hooks && Object.keys(rootHooks.hooks).length > 0;
+        if (!dryRun && hasCursorTarget && (hasHooks || rootHookFiles.length > 0)) {
+            (0, hooks_1.writeHooksToCursor)(rootHooks, rootHookFiles, cwd);
+        }
+        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"}`);
+                    }
+                    if (pkg.installedHookCount > 0) {
+                        summaryParts.push(`${pkg.installedHookCount} hook${pkg.installedHookCount === 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`
+                    : "";
+                const hookSummary = result.totalHookCount > 0
+                    ? `, ${result.totalHookCount} hook${result.totalHookCount === 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}${hookSummary})`));
+                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,
+                installedHookCount: result.totalHookCount,
+                packagesCount: result.packages.length,
+            };
+        }
+        return {
+            success: true,
+            installedRuleCount: result.totalRuleCount,
+            installedCommandCount: result.totalCommandCount,
+            installedAssetCount: result.totalAssetCount,
+            installedHookCount: result.totalHookCount,
+            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()
@@ -45,11 +45,23 @@ export interface InstallResult {
      * Number of assets installed
      */
     installedAssetCount: number;
+    /**
+     * Number of hooks installed
+     */
+    installedHookCount: number;
     /**
      * Number of packages installed
      */
     packagesCount: number;
 }
+export declare function writeAssetsToTargets(assets: AssetFile[], targets: SupportedTarget[]): void;
+export declare function writeCommandsToTargets(commands: CommandFile[], 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)
  */