aicm 0.12.0 → 0.12.1

package/README.md

@@ -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,6 +219,7 @@ 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.
 
@@ -292,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/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/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.12.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",