aicm 0.12.0 → 0.12.2

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,10 +219,19 @@ 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
+- **rules**: Object containing rule configurations.
+  If you want to install every rule from a single directory, you can also use a
+  string as a shortcut:
+
+  ```json
+  {
+    "rules": "./rules/*"
+  }
+  ```
 
   - **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). Supports glob patterns for automatic file discovery.
@@ -292,6 +301,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
 
@@ -396,3 +406,9 @@ npm run test:unit
 # Run only E2E tests
 npm run test:e2e
 ```
+
+### Publishing
+
+```bash
+npm run release
+```

package/dist/api.d.ts

@@ -5,4 +5,4 @@ import { InstallOptions, InstallResult } from "./commands/install";
  * @returns Result of the install operation
  */
 export declare function install(options?: InstallOptions): Promise<InstallResult>;
-export { Config, Rule, Rules, RuleMetadata, RuleContent, RuleCollection, } from "./types";
+export { Config, NormalizedConfig, Rule, Rules, RuleMetadata, RuleContent, RuleCollection, } from "./types";

package/dist/commands/install.d.ts

@@ -1,4 +1,4 @@
-import { Config } from "../types";
+import { NormalizedConfig } from "../types";
 /**
  * Options for the installCore function
  */
@@ -10,7 +10,7 @@ export interface InstallOptions {
     /**
      * Custom config object to use instead of loading from file
      */
-    config?: Config;
+    config?: NormalizedConfig;
     /**
      * allow installation on CI environments
      */

package/dist/types/index.d.ts

@@ -17,12 +17,16 @@ export interface MCPServers {
     [serverName: string]: MCPServer;
 }
 export interface Config {
-    ides: string[];
-    rules: Rules;
+    ides?: string[];
+    rules?: Rules | string;
     presets?: string[];
     mcpServers?: MCPServers;
     installOnCI?: boolean;
 }
+export interface NormalizedConfig extends Omit<Config, "rules"> {
+    ides: string[];
+    rules: Rules;
+}
 export interface RuleMetadata {
     type?: string;
     alwaysApply?: boolean | string;
@@ -40,11 +44,12 @@ export interface RuleContent {
 export interface RuleCollection {
     cursor: RuleContent[];
     windsurf: RuleContent[];
+    codex: RuleContent[];
 }
 export interface PackageInfo {
     relativePath: string;
     absolutePath: string;
-    config: Config;
+    config: NormalizedConfig;
 }
 export interface WorkspacesInstallResult {
     success: boolean;

package/dist/utils/config.d.ts

@@ -1,12 +1,13 @@
-import { Config, Rules } from "../types";
+import { Config, NormalizedConfig, Rules } from "../types";
 export interface RuleMetadata {
     ruleSources: Record<string, string>;
     originalPresetPaths: Record<string, string>;
 }
 export interface ConfigResult {
-    config: Config;
+    config: NormalizedConfig;
     metadata: RuleMetadata;
 }
+export declare function normalizeRules(rules: Rules | string | undefined): Rules;
 export interface PresetPathInfo {
     fullPath: string;
     originalPath: string;
@@ -24,19 +25,19 @@ export declare function loadPreset(presetPath: string, cwd?: string): {
  * Load the aicm config using cosmiconfigSync, supporting both aicm.json and package.json.
  * Returns the config object or null if not found.
  */
-export declare function loadAicmConfigCosmiconfig(searchFrom?: string): Config | null;
+export declare function loadAicmConfigCosmiconfig(searchFrom?: string): NormalizedConfig | null;
 /**
  * Get the configuration from aicm.json or package.json (using cosmiconfigSync) and merge with any presets
  */
-export declare function getConfig(cwd?: string): Config | null;
+export declare function getConfig(cwd?: string): NormalizedConfig | null;
 /**
  * Get the source preset path for a rule if it came from a preset
  */
-export declare function getRuleSource(config: Config, ruleName: string): string | undefined;
+export declare function getRuleSource(config: NormalizedConfig, ruleName: string): string | undefined;
 /**
  * Get the original preset path for a rule if it came from a preset
  */
-export declare function getOriginalPresetPath(config: Config, ruleName: string): string | undefined;
+export declare function getOriginalPresetPath(config: NormalizedConfig, ruleName: string): string | undefined;
 /**
  * Save the configuration to the aicm.json file
  */

package/dist/utils/config.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeRules = normalizeRules;
 exports.getFullPresetPath = getFullPresetPath;
 exports.loadPreset = loadPreset;
 exports.loadAicmConfigCosmiconfig = loadAicmConfigCosmiconfig;
@@ -14,6 +15,14 @@ const fs_extra_1 = __importDefault(require("fs-extra"));
 const node_path_1 = __importDefault(require("node:path"));
 const cosmiconfig_1 = require("cosmiconfig");
 const CONFIG_FILE = "aicm.json";
+function normalizeRules(rules) {
+    if (!rules)
+        return {};
+    if (typeof rules === "string") {
+        return { "/": rules };
+    }
+    return rules;
+}
 function getFullPresetPath(presetPath, cwd) {
     const workingDir = cwd || process.cwd();
     // If it's a local file with .json extension, check relative to the working directory
@@ -82,11 +91,12 @@ function loadPreset(presetPath, cwd) {
         const parseError = error;
         throw new Error(`Error loading preset: Invalid JSON in ${presetPath}: ${parseError.message}`);
     }
-    if (!preset.rules || typeof preset.rules !== "object") {
+    if (!preset.rules) {
         throw new Error(`Error loading preset: Invalid format in ${presetPath} - missing or invalid 'rules' object`);
     }
+    const normalizedRules = normalizeRules(preset.rules);
     return {
-        rules: preset.rules,
+        rules: normalizedRules,
         mcpServers: preset.mcpServers,
         presets: preset.presets,
     };
@@ -214,11 +224,13 @@ function loadAicmConfigCosmiconfig(searchFrom) {
         const result = explorer.search(searchFrom);
         if (!result || !result.config)
             return null;
-        const config = result.config;
-        if (!config.rules)
-            config.rules = {};
-        if (!config.ides)
-            config.ides = ["cursor"];
+        const rawConfig = result.config;
+        const normalizedRules = normalizeRules(rawConfig.rules);
+        const config = {
+            ...rawConfig,
+            ides: rawConfig.ides || ["cursor"],
+            rules: normalizedRules,
+        };
         return config;
     }
     catch (error) {

package/dist/utils/mcp-writer.d.ts

@@ -1,14 +1,14 @@
-import { Config } from "../types";
+import { NormalizedConfig } 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;
+export declare function writeMcpServersToTargets(mcpServers: NormalizedConfig["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;
+export declare function writeMcpServersToFile(mcpServers: NormalizedConfig["mcpServers"], mcpPath: string): void;

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.2",
   "description": "A TypeScript CLI tool for managing AI IDE rules across different projects and teams",
   "main": "dist/api.js",
   "types": "dist/api.d.ts",
@@ -12,22 +12,6 @@
     "README.md",
     "LICENSE"
   ],
-  "scripts": {
-    "build": "tsc",
-    "watch": "tsc --watch",
-    "start": "node dist/index.js",
-    "dev": "ts-node src/index.ts",
-    "test": "jest",
-    "test:watch": "jest --watch",
-    "test:all": "npm run build && npm run test",
-    "test:unit": "jest --config jest.unit.config.js",
-    "test:e2e": "jest tests/e2e",
-    "format": "prettier --write .",
-    "format:check": "prettier --check .",
-    "lint": "eslint",
-    "prepare": "husky install && npx ts-node src/index.ts install",
-    "version": "auto-changelog -p && git add CHANGELOG.md"
-  },
   "keywords": [
     "ai",
     "ide",
@@ -58,6 +42,7 @@
     "lint-staged": "^15.2.0",
     "mock-fs": "^5.2.0",
     "nock": "^13.3.8",
+    "np": "^10.2.0",
     "prettier": "^3.1.0",
     "rimraf": "^5.0.5",
     "ts-jest": "^29.1.1",
@@ -68,5 +53,21 @@
   "lint-staged": {
     "*.{js,ts,json,md,mjs}": "prettier --write",
     "*.ts": "eslint"
+  },
+  "scripts": {
+    "build": "tsc",
+    "watch": "tsc --watch",
+    "start": "node dist/index.js",
+    "dev": "ts-node src/index.ts",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:all": "npm run build && npm run test",
+    "test:unit": "jest --config jest.unit.config.js",
+    "test:e2e": "jest tests/e2e",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "lint": "eslint",
+    "version": "auto-changelog -p && git add CHANGELOG.md",
+    "release": "np"
   }
-}
+}