aicm 0.11.0 → 0.12.1

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
 
@@ -94,7 +94,7 @@ When you run `npx aicm install`, all rules from the preset will be installed to
 ### Notes
 
 - Generated rules are always placed in a subdirectory for deterministic cleanup and easy gitignore.
-- Users may add `.cursor/rules/aicm/` and `.aicm/` (for Windsurf) to their `.gitignore` if they do not want to track generated rules.
+- Users may add `.cursor/rules/aicm/` and `.aicm/` (for Windsurf/Codex) to their `.gitignore` if they do not want to track generated rules.
 
 ### Overriding and Disabling Rules and MCP Servers from Presets
 
@@ -219,13 +219,39 @@ Example `aicm.json`:
 
   - `"cursor"`: For the Cursor IDE
   - `"windsurf"`: For the Windsurf IDE
+  - `"codex"`: For the Codex Agent
 
   > **Note:** The 'ides' field is default to `["cursor"]` if not specified.
 
 - **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:
 
@@ -267,6 +293,7 @@ Rules stored locally in your project or filesystem. Any path containing slashes
 
 - **Cursor**: Rules are installed as individual `.mdc` files in the Cursor rules directory (`.cursor/rules/aicm/`), mcp servers are installed to `.cursor/mcp.json`
 - **Windsurf**: Rules are installed in the `.aicm` directory which should be added to your `.gitignore` file. Our approach for Windsurf is to create links from the `.windsurfrules` file to the respective rules in the `.aicm` directory. There is no support for local mcp servers at the moment.
+- **Codex**: Rules are installed in the `.aicm` directory and referenced from `AGENTS.md` using the same markers as Windsurf.
 
 ## Commands
 

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/types/index.d.ts

@@ -40,6 +40,7 @@ export interface RuleContent {
 export interface RuleCollection {
     cursor: RuleContent[];
     windsurf: RuleContent[];
+    codex: RuleContent[];
 }
 export interface PackageInfo {
     relativePath: string;

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/rule-collector.js

@@ -59,6 +59,7 @@ function initRuleCollection() {
     return {
         cursor: [],
         windsurf: [],
+        codex: [],
     };
 }
 /**
@@ -77,6 +78,10 @@ function addRuleToCollection(collection, rule, ides) {
             !collection.windsurf.some((r) => r.name === rule.name)) {
             collection.windsurf.push(rule);
         }
+        else if (ide === "codex" &&
+            !collection.codex.some((r) => r.name === rule.name)) {
+            collection.codex.push(rule);
+        }
     }
 }
 /**

package/dist/utils/rule-status.js

@@ -15,6 +15,7 @@ function getIdePaths() {
     return {
         cursor: node_path_1.default.join(projectDir, ".cursor", "rules", "aicm"),
         windsurf: node_path_1.default.join(projectDir, ".aicm"),
+        codex: node_path_1.default.join(projectDir, ".aicm"),
     };
 }
 /**
@@ -38,6 +39,15 @@ function checkRuleStatus(ruleName, ides) {
             }
             return false;
         }
+        if (ide === "codex") {
+            const ruleExists = fs_extra_1.default.existsSync(node_path_1.default.join(idePaths[ide], `${ruleName}.md`));
+            const codexFilePath = node_path_1.default.join(process.cwd(), "AGENTS.md");
+            if (fs_extra_1.default.existsSync(codexFilePath)) {
+                const codexContent = fs_extra_1.default.readFileSync(codexFilePath, "utf8");
+                return ruleExists && codexContent.includes(`.aicm/${ruleName}.md`);
+            }
+            return false;
+        }
         return false;
     });
 }

package/dist/utils/rule-writer.js

@@ -7,7 +7,7 @@ exports.writeRulesToTargets = writeRulesToTargets;
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const node_path_1 = __importDefault(require("node:path"));
 const rule_status_1 = require("./rule-status");
-const windsurf_writer_1 = require("./windsurf-writer");
+const rules_file_writer_1 = require("./rules-file-writer");
 /**
  * Write all collected rules to their respective IDE targets
  * @param collection The collection of rules to write
@@ -20,7 +20,10 @@ function writeRulesToTargets(collection) {
     }
     // Write Windsurf rules
     if (collection.windsurf.length > 0) {
-        writeWindsurfRulesFromCollection(collection.windsurf, idePaths.windsurf);
+        writeRulesForFile(collection.windsurf, idePaths.windsurf, ".windsurfrules");
+    }
+    if (collection.codex.length > 0) {
+        writeRulesForFile(collection.codex, idePaths.codex, "AGENTS.md");
     }
 }
 /**
@@ -71,10 +74,10 @@ function writeCursorRules(rules, cursorRulesDir) {
     }
 }
 /**
- * Write rules to Windsurf's rules directory and update .windsurfrules file
+ * Write rules to a shared directory and update the given rules file
  * @param rules The rules to write
  */
-function writeWindsurfRulesFromCollection(rules, ruleDir) {
+function writeRulesForFile(rules, ruleDir, rulesFile) {
     fs_extra_1.default.emptyDirSync(ruleDir);
     const ruleFiles = rules.map((rule) => {
         let rulePath;
@@ -94,7 +97,7 @@ function writeWindsurfRulesFromCollection(rules, ruleDir) {
         fs_extra_1.default.ensureDirSync(node_path_1.default.dirname(physicalRulePath));
         fs_extra_1.default.writeFileSync(physicalRulePath, rule.content);
         const relativeRuleDir = node_path_1.default.basename(ruleDir); // Gets '.rules'
-        // For the Windsurf rules file, we need to maintain the same structure
+        // For the rules file, maintain the same structure
         let windsurfPath;
         if (rule.presetPath) {
             const namespace = extractNamespaceFromPresetPath(rule.presetPath);
@@ -112,6 +115,6 @@ function writeWindsurfRulesFromCollection(rules, ruleDir) {
             metadata: rule.metadata,
         };
     });
-    const windsurfRulesContent = (0, windsurf_writer_1.generateWindsurfRulesContent)(ruleFiles);
-    (0, windsurf_writer_1.writeWindsurfRules)(windsurfRulesContent);
+    const windsurfRulesContent = (0, rules_file_writer_1.generateRulesFileContent)(ruleFiles);
+    (0, rules_file_writer_1.writeRulesFile)(windsurfRulesContent, node_path_1.default.join(process.cwd(), rulesFile));
 }

package/dist/utils/rules-file-writer.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Write rules to the .windsurfrules file
+ * This will update the content between the RULES_BEGIN and RULES_END markers
+ * If the file doesn't exist, it will create it
+ * If the markers don't exist, it will append them to the existing content
+ */
+export declare function writeRulesFile(rulesContent: string, rulesFilePath?: string): void;
+/**
+ * Generate the rules file content based on rule files
+ */
+export declare function generateRulesFileContent(ruleFiles: {
+    name: string;
+    path: string;
+    metadata: Record<string, string | boolean | string[]>;
+}[]): string;

package/dist/utils/rules-file-writer.js

@@ -0,0 +1,137 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeRulesFile = writeRulesFile;
+exports.generateRulesFileContent = generateRulesFileContent;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const RULES_BEGIN = "<!-- AICM:BEGIN -->";
+const RULES_END = "<!-- AICM:END -->";
+const WARNING = "<!-- WARNING: Everything between these markers will be overwritten during installation -->";
+/**
+ * Create a formatted block of content with rules markers
+ */
+function createRulesBlock(rulesContent) {
+    return `${RULES_BEGIN}
+${WARNING}
+
+${rulesContent}
+
+${RULES_END}`;
+}
+/**
+ * Write rules to the .windsurfrules file
+ * This will update the content between the RULES_BEGIN and RULES_END markers
+ * If the file doesn't exist, it will create it
+ * If the markers don't exist, it will append them to the existing content
+ */
+function writeRulesFile(rulesContent, rulesFilePath = path_1.default.join(process.cwd(), ".windsurfrules")) {
+    let fileContent;
+    const formattedRulesBlock = createRulesBlock(rulesContent);
+    // Check if file exists
+    if (fs_extra_1.default.existsSync(rulesFilePath)) {
+        const existingContent = fs_extra_1.default.readFileSync(rulesFilePath, "utf8");
+        // Check if our markers exist
+        if (existingContent.includes(RULES_BEGIN) &&
+            existingContent.includes(RULES_END)) {
+            // Replace content between markers
+            const beforeMarker = existingContent.split(RULES_BEGIN)[0];
+            const afterMarker = existingContent.split(RULES_END)[1];
+            fileContent = beforeMarker + formattedRulesBlock + afterMarker;
+        }
+        else {
+            // Preserve the existing content and append markers
+            // Ensure there's proper spacing between existing content and markers
+            let separator = "";
+            if (!existingContent.endsWith("\n")) {
+                separator += "\n";
+            }
+            // Add an extra line if the file doesn't already end with multiple newlines
+            if (!existingContent.endsWith("\n\n")) {
+                separator += "\n";
+            }
+            // Create the new file content with preserved original content
+            fileContent = existingContent + separator + formattedRulesBlock;
+        }
+    }
+    else {
+        // Create new file with markers and content
+        fileContent = formattedRulesBlock;
+    }
+    fs_extra_1.default.writeFileSync(rulesFilePath, fileContent);
+}
+/**
+ * Generate the rules file content based on rule files
+ */
+function generateRulesFileContent(ruleFiles) {
+    const alwaysRules = [];
+    const autoAttachedRules = [];
+    const agentRequestedRules = [];
+    const manualRules = [];
+    ruleFiles.forEach(({ path, metadata }) => {
+        // Determine rule type based on metadata
+        if (metadata.type === "always" ||
+            metadata.alwaysApply === true ||
+            metadata.alwaysApply === "true") {
+            alwaysRules.push(path);
+        }
+        else if (metadata.type === "auto-attached" || metadata.globs) {
+            const globPattern = typeof metadata.globs === "string" || Array.isArray(metadata.globs)
+                ? Array.isArray(metadata.globs)
+                    ? metadata.globs.join(", ")
+                    : metadata.globs
+                : undefined;
+            if (globPattern !== undefined) {
+                autoAttachedRules.push({ path, glob: globPattern });
+            }
+        }
+        else if (metadata.type === "agent-requested" || metadata.description) {
+            agentRequestedRules.push(path);
+        }
+        else {
+            // Default to manual inclusion
+            manualRules.push(path);
+        }
+    });
+    // Generate the content
+    let content = "";
+    // Always rules
+    if (alwaysRules.length > 0) {
+        content +=
+            "The following rules always apply to all files in the project:\n";
+        alwaysRules.forEach((rule) => {
+            content += `- ${rule}\n`;
+        });
+        content += "\n";
+    }
+    // Auto Attached rules
+    if (autoAttachedRules.length > 0) {
+        content +=
+            "The following rules are automatically attached to matching glob patterns:\n";
+        autoAttachedRules.forEach((rule) => {
+            content += `- [${rule.glob}] ${rule.path}\n`;
+        });
+        content += "\n";
+    }
+    // Agent Requested rules
+    if (agentRequestedRules.length > 0) {
+        content +=
+            "The following rules are available for the AI to include when needed:\n";
+        agentRequestedRules.forEach((rule) => {
+            content += `- ${rule}\n`;
+        });
+        content += "\n";
+    }
+    // Manual rules
+    if (manualRules.length > 0) {
+        content +=
+            "The following rules are only included when explicitly referenced:\n";
+        manualRules.forEach((rule) => {
+            content += `- ${rule}\n`;
+        });
+        content += "\n";
+    }
+    return content.trim();
+}

package/package.json

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