aicm 0.11.0 → 0.12.0

package/README.md

@@ -4,7 +4,7 @@
 
 A CLI tool for managing Agentic IDE configurations across projects
 
-https://github.com/user-attachments/assets/e80dedbc-89c4-4747-9acf-b7ecb7493fcc
+![aicm](https://github.com/user-attachments/assets/ca38f2d6-ece6-43ad-a127-6f4fce8b2a5a)
 
 ## Why
 
@@ -225,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

@@ -14,6 +14,7 @@ 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
@@ -146,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) {
@@ -173,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;
                 }
@@ -186,7 +197,6 @@ async function install(options = {}) {
                 errorMessages.push(errorMessage);
             }
         }
-        // If there were errors, exit with error
         if (hasErrors) {
             return {
                 success: false,
@@ -195,11 +205,8 @@ 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));
             (0, mcp_writer_1.writeMcpServersToTargets)(filteredMcpServers, config.ides, cwd);
         }

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

@@ -1,6 +1,6 @@
 {
   "name": "aicm",
-  "version": "0.11.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": {