aicm 0.10.0 → 0.12.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
+![aicm](https://github.com/user-attachments/assets/ca38f2d6-ece6-43ad-a127-6f4fce8b2a5a)
 
-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
 
@@ -219,7 +225,32 @@ Example `aicm.json`:
 - **rules**: Object containing rule configurations
 
   - **rule-name**: A unique identifier for the rule. Can include a directory path to install the rule to a specific directory.
-  - **source-location**: Location of the rule file (path within an npm package or local path)
+  - **source-location**: Location of the rule file (path within an npm package or local path). Supports glob patterns for automatic file discovery.
+
+#### Glob Pattern Support
+
+Rules support glob patterns for automatic discovery of multiple `.mdc` files. This is particularly useful when you have multiple related rules organized in directories.
+
+```json
+{
+  "rules": {
+    "typescript": "./rules/typescript/*.mdc",
+    "tests": "./rules/testing/**/*.mdc"
+  }
+}
+```
+
+The key becomes the base namespace for discovered files:
+
+- `./rules/typescript/strict.mdc` → installed as `typescript/strict`
+- `./rules/typescript/interfaces.mdc` → installed as `typescript/interfaces`
+- `./rules/testing/unit/setup.mdc` → installed as `tests/unit/setup`
+
+**Installation Behavior:**
+
+- Glob patterns are expanded during installation
+- Only `.mdc` files are included
+- Files are sorted alphabetically for consistent behavior
 
 - **mcpServers**: Object containing MCP server configurations. Each key is a unique server name, and the value is an object with either:
 

package/dist/commands/install.js

@@ -10,11 +10,11 @@ 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");
+const glob_handler_1 = require("../utils/glob-handler");
 /**
  * Helper function to execute a function within a specific working directory
  * and ensure the original directory is always restored
@@ -33,27 +33,6 @@ async function withWorkingDirectory(targetDir, fn) {
         }
     }
 }
-/**
- * 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) {
-        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 });
-        }
-    }
-}
 /**
  * Checks if the current environment is a CI environment
  * This function respects any explicit settings in process.env.CI
@@ -168,20 +147,31 @@ async function install(options = {}) {
                 };
             }
         }
-        // Process each rule
+        let expandedRules;
+        try {
+            const expansion = await (0, glob_handler_1.expandRulesGlobPatterns)(config.rules, cwd);
+            expandedRules = expansion.expandedRules;
+            if (options.verbose) {
+                for (const [expandedKey, originalPattern] of Object.entries(expansion.globSources)) {
+                    console.log(chalk_1.default.gray(`  Pattern "${originalPattern}" → ${expandedKey}`));
+                }
+            }
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Error expanding glob patterns: ${error instanceof Error ? error.message : String(error)}`,
+                installedRuleCount: 0,
+                packagesCount: 0,
+            };
+        }
         let hasErrors = false;
         const errorMessages = [];
         let installedRuleCount = 0;
-        for (const [name, source] of Object.entries(config.rules)) {
-            if (source === false)
-                continue; // skip canceled rules
-            // Detect rule type from the source string
+        for (const [name, source] of Object.entries(expandedRules)) {
             const ruleType = (0, rule_detector_1.detectRuleType)(source);
-            // Get the base path of the preset file if this rule came from a preset
             const ruleBasePath = (0, config_1.getRuleSource)(config, name);
-            // Get the original preset path for namespacing
             const originalPresetPath = (0, config_1.getOriginalPresetPath)(config, name);
-            // Collect the rule based on its type
             try {
                 let ruleContent;
                 switch (ruleType) {
@@ -195,7 +185,6 @@ async function install(options = {}) {
                         errorMessages.push(`Unknown rule type: ${ruleType}`);
                         continue;
                 }
-                // Add the preset path to the rule content for namespacing
                 if (originalPresetPath) {
                     ruleContent.presetPath = originalPresetPath;
                 }
@@ -208,7 +197,6 @@ async function install(options = {}) {
                 errorMessages.push(errorMessage);
             }
         }
-        // If there were errors, exit with error
         if (hasErrors) {
             return {
                 success: false,
@@ -217,13 +205,10 @@ async function install(options = {}) {
                 packagesCount: 0,
             };
         }
-        // Write all collected rules to their targets
         (0, rule_writer_1.writeRulesToTargets)(ruleCollection);
-        // Write mcpServers config to IDE targets
         if (config.mcpServers) {
-            // Filter out canceled servers
             const filteredMcpServers = Object.fromEntries(Object.entries(config.mcpServers).filter(([, v]) => v !== false));
-            writeMcpServersToTargets(filteredMcpServers, config.ides, cwd);
+            (0, mcp_writer_1.writeMcpServersToTargets)(filteredMcpServers, config.ides, cwd);
         }
         return {
             success: true,

package/dist/utils/glob-handler.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Check if a rule source string contains glob patterns
+ */
+export declare function isGlobPattern(source: string): boolean;
+/**
+ * Expand a glob pattern to matching .mdc files
+ * @param pattern The glob pattern to expand
+ * @param basePath The base path to resolve relative patterns from
+ * @returns Array of file paths that match the pattern
+ */
+export declare function expandGlobPattern(pattern: string, basePath?: string): Promise<string[]>;
+/**
+ * Generate a rule key from a file path and base key
+ * @param filePath The discovered file path
+ * @param baseKey The base key from the object notation
+ * @param patternBase The base directory of the glob pattern
+ * @returns Generated rule key with namespace
+ */
+export declare function generateGlobRuleKey(filePath: string, baseKey: string, patternBase: string): string;
+/**
+ * Get the base directory from a glob pattern
+ * @param pattern The glob pattern
+ * @returns The base directory path without glob characters
+ */
+export declare function getGlobBase(pattern: string): string;
+/**
+ * Expand glob patterns in rules object and return normalized rules
+ * @param rules The rules object that may contain glob patterns
+ * @param basePath The base path to resolve relative patterns from
+ * @returns Object with expanded rules and metadata about sources
+ */
+export declare function expandRulesGlobPatterns(rules: Record<string, string | false>, basePath?: string): Promise<{
+    expandedRules: Record<string, string>;
+    globSources: Record<string, string>;
+}>;

package/dist/utils/glob-handler.js

@@ -0,0 +1,125 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isGlobPattern = isGlobPattern;
+exports.expandGlobPattern = expandGlobPattern;
+exports.generateGlobRuleKey = generateGlobRuleKey;
+exports.getGlobBase = getGlobBase;
+exports.expandRulesGlobPatterns = expandRulesGlobPatterns;
+const node_path_1 = __importDefault(require("node:path"));
+const fast_glob_1 = __importDefault(require("fast-glob"));
+/**
+ * Check if a rule source string contains glob patterns
+ */
+function isGlobPattern(source) {
+    return /[*?{}[\]]/.test(source);
+}
+/**
+ * Expand a glob pattern to matching .mdc files
+ * @param pattern The glob pattern to expand
+ * @param basePath The base path to resolve relative patterns from
+ * @returns Array of file paths that match the pattern
+ */
+async function expandGlobPattern(pattern, basePath) {
+    // Normalize the pattern to use forward slashes for consistent behavior
+    const normalizedPattern = pattern.replace(/\\/g, "/");
+    try {
+        const matches = await (0, fast_glob_1.default)(normalizedPattern, {
+            ignore: ["**/.*"], // Ignore hidden files
+            absolute: false,
+            onlyFiles: true,
+            // Set the working directory if basePath is provided
+            cwd: basePath,
+        });
+        // Filter to only .mdc files, normalize paths, and sort for deterministic behavior
+        return matches
+            .filter((file) => file.endsWith(".mdc"))
+            .map((file) => file.replace(/\\/g, "/")) // Normalize Windows backslashes to forward slashes
+            .sort((a, b) => a.localeCompare(b));
+    }
+    catch (error) {
+        throw new Error(`Error expanding glob pattern "${pattern}": ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Generate a rule key from a file path and base key
+ * @param filePath The discovered file path
+ * @param baseKey The base key from the object notation
+ * @param patternBase The base directory of the glob pattern
+ * @returns Generated rule key with namespace
+ */
+function generateGlobRuleKey(filePath, baseKey, patternBase) {
+    // Normalize paths to use forward slashes for consistent behavior
+    const normalizedFilePath = filePath.replace(/\\/g, "/");
+    const normalizedPatternBase = patternBase.replace(/\\/g, "/");
+    // Get the relative path from the pattern base to the file
+    const relativePath = node_path_1.default.posix.relative(normalizedPatternBase, normalizedFilePath);
+    // Remove .mdc extension
+    const withoutExtension = relativePath.replace(/\.mdc$/, "");
+    // Return the combined key
+    return `${baseKey}/${withoutExtension}`;
+}
+/**
+ * Get the base directory from a glob pattern
+ * @param pattern The glob pattern
+ * @returns The base directory path without glob characters
+ */
+function getGlobBase(pattern) {
+    // Normalize path separators to forward slashes for consistent behavior
+    const normalizedPattern = pattern.replace(/\\/g, "/");
+    // Find the first occurrence of glob characters
+    const globIndex = normalizedPattern.search(/[*?{}[\]]/);
+    if (globIndex === -1) {
+        // No glob characters, return the directory
+        return node_path_1.default.dirname(normalizedPattern);
+    }
+    // Get the path up to the first glob character
+    const basePath = normalizedPattern.substring(0, globIndex);
+    // Find the last path separator before the glob
+    const lastSeparator = basePath.lastIndexOf("/");
+    if (lastSeparator === -1) {
+        return ".";
+    }
+    return basePath.substring(0, lastSeparator);
+}
+/**
+ * Expand glob patterns in rules object and return normalized rules
+ * @param rules The rules object that may contain glob patterns
+ * @param basePath The base path to resolve relative patterns from
+ * @returns Object with expanded rules and metadata about sources
+ */
+async function expandRulesGlobPatterns(rules, basePath) {
+    const expandedRules = {};
+    const globSources = {};
+    for (const [key, source] of Object.entries(rules)) {
+        if (source === false) {
+            continue; // Skip canceled rules
+        }
+        if (isGlobPattern(source)) {
+            // Expand glob pattern
+            try {
+                const matchedFiles = await expandGlobPattern(source, basePath);
+                if (matchedFiles.length === 0) {
+                    console.warn(`Warning: Glob pattern "${source}" matched no files`);
+                    continue;
+                }
+                const patternBase = getGlobBase(source);
+                for (const filePath of matchedFiles) {
+                    const generatedKey = generateGlobRuleKey(filePath, key, patternBase);
+                    expandedRules[generatedKey] = filePath;
+                    globSources[generatedKey] = source;
+                }
+            }
+            catch (error) {
+                throw new Error(`Error processing glob pattern for key "${key}": ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        else {
+            // Regular file path
+            expandedRules[key] = source;
+        }
+    }
+    return { expandedRules, globSources };
+}

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aicm",
-  "version": "0.10.0",
+  "version": "0.12.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",
@@ -43,6 +43,7 @@
     "chalk": "^4.1.2",
     "ci-info": "^4.2.0",
     "cosmiconfig": "^9.0.0",
+    "fast-glob": "^3.3.3",
     "fs-extra": "^11.1.1"
   },
   "devDependencies": {