aicm 0.14.5 → 0.15.1

package/README.md

@@ -17,7 +17,9 @@ Modern AI-powered IDEs like Cursor and Agents like Codex enable developers to wr
 aicm accepts Cursor's `.mdc` format as it provides the most comprehensive feature set. For other AI tools and IDEs, aicm automatically generates compatible formats:
 
 - **Cursor**: Native `.mdc` files with full feature support
-- **Windsurf/Codex**: Generates `.windsurfrules`/`AGENTS.md` files with natural language adaptations
+- **Windsurf**: Generates `.windsurfrules` file
+- **Codex**: Generates `AGENTS.md` file
+- **Claude**: Generates `CLAUDE.md` file
 
 This approach ensures you write your rules once in the richest format available, while maintaining compatibility across different AI development environments.
 
@@ -160,6 +162,7 @@ aicm automatically detects workspaces if your `package.json` contains a `workspa
 
 1. **Discover packages**: Automatically find all directories containing `aicm.json` files in your repository
 2. **Install per package**: Install rules and MCPs for each package individually in their respective directories
+3. **Merge MCP servers**: Write a merged `.cursor/mcp.json` at the repository root containing all MCP servers from every package
 
 ### How It Works
 
@@ -185,6 +188,20 @@ Running `npx aicm install` will install rules for each package in their respecti
 - `packages/backend/.cursor/rules/aicm/`
 - `services/api/.cursor/rules/aicm/`
 
+### Preset Packages in Workspaces
+
+When you have a preset package within your workspace (a package that provides rules to be consumed by others), you can prevent aicm from installing rules into it by setting `skipInstall: true`:
+
+```json
+{
+  "skipInstall": true,
+  "rulesDir": "./rules",
+  "targets": ["cursor"]
+}
+```
+
+This is useful when your workspace contains both consumer packages (that need rules installed) and provider packages (that only export rules).
+
 ## Configuration
 
 Create an `aicm.json` file in your project root, or an `aicm` key in your project's `package.json`.
@@ -195,7 +212,8 @@ Create an `aicm.json` file in your project root, or an `aicm` key in your projec
   "targets": ["cursor"],
   "presets": [],
   "overrides": {},
-  "mcpServers": {}
+  "mcpServers": {},
+  "skipInstall": false
 }
 ```
 
@@ -205,6 +223,7 @@ Create an `aicm.json` file in your project root, or an `aicm` key in your projec
 - **overrides**: Map of rule names to `false` (disable) or a replacement file path.
 - **mcpServers**: MCP server configurations.
 - **workspaces**: Set to `true` to enable workspace mode. If not specified, aicm will automatically detect workspaces from your `package.json`.
+- **skipInstall**: Set to `true` to skip rule installation for this package. Useful for preset packages that provide rules but shouldn't have rules installed into them.
 
 ### MCP Server Installation
 

package/dist/commands/install.js

@@ -13,12 +13,14 @@ const child_process_1 = require("child_process");
 const config_1 = require("../utils/config");
 const working_directory_1 = require("../utils/working-directory");
 const is_ci_1 = require("../utils/is-ci");
+const rules_file_writer_1 = require("../utils/rules-file-writer");
 function getTargetPaths() {
     const projectDir = process.cwd();
     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"),
+        claude: node_path_1.default.join(projectDir, ".aicm"),
     };
 }
 function writeCursorRules(rules, cursorRulesDir) {
@@ -50,80 +52,6 @@ function extractNamespaceFromPresetPath(presetPath) {
     const parts = presetPath.split(node_path_1.default.sep);
     return parts.filter((part) => part.length > 0); // Filter out empty segments
 }
-function generateRulesFileContent(ruleFiles) {
-    const alwaysApplyRules = [];
-    const optInRules = [];
-    for (const rule of ruleFiles) {
-        // Parse metadata to determine rule type
-        const metadata = rule.content.match(/^---\n([\s\S]*?)\n---/);
-        let alwaysApply = false;
-        if (metadata) {
-            try {
-                const frontmatter = metadata[1];
-                // Simple YAML parsing for alwaysApply field
-                const alwaysApplyMatch = frontmatter.match(/alwaysApply:\s*(true|false)/);
-                if (alwaysApplyMatch) {
-                    alwaysApply = alwaysApplyMatch[1] === "true";
-                }
-            }
-            catch (_a) {
-                // If parsing fails, default to false
-            }
-        }
-        if (alwaysApply) {
-            alwaysApplyRules.push(`- ${rule.path}`);
-        }
-        else {
-            optInRules.push(`- ${rule.path}`);
-        }
-    }
-    let content = "<!-- AICM:BEGIN -->\n";
-    if (alwaysApplyRules.length > 0) {
-        content +=
-            "The following rules always apply to all files in the project:\n";
-        content += alwaysApplyRules.join("\n") + "\n\n";
-    }
-    if (optInRules.length > 0) {
-        content +=
-            "The following rules are available for the AI to include when needed:\n";
-        content += optInRules.join("\n") + "\n\n";
-    }
-    content += "<!-- AICM:END -->";
-    return content;
-}
-/**
- * Write rules file content to a file, preserving existing content outside markers
- */
-function writeRulesFile(rulesContent, rulesFilePath) {
-    const RULES_BEGIN = "<!-- AICM:BEGIN -->";
-    const RULES_END = "<!-- AICM:END -->";
-    let fileContent;
-    if (fs_extra_1.default.existsSync(rulesFilePath)) {
-        const existingContent = fs_extra_1.default.readFileSync(rulesFilePath, "utf8");
-        if (existingContent.includes(RULES_BEGIN) &&
-            existingContent.includes(RULES_END)) {
-            const beforeMarker = existingContent.split(RULES_BEGIN)[0];
-            const afterMarker = existingContent.split(RULES_END)[1];
-            fileContent = beforeMarker + rulesContent + afterMarker;
-        }
-        else {
-            // Preserve the existing content and append markers
-            let separator = "";
-            if (!existingContent.endsWith("\n")) {
-                separator += "\n";
-            }
-            if (!existingContent.endsWith("\n\n")) {
-                separator += "\n";
-            }
-            fileContent = existingContent + separator + rulesContent;
-        }
-    }
-    else {
-        // Create new file with markers and content
-        fileContent = rulesContent + "\n";
-    }
-    fs_extra_1.default.writeFileSync(rulesFilePath, fileContent);
-}
 /**
  * Write rules to a shared directory and update the given rules file
  */
@@ -161,11 +89,11 @@ function writeRulesForFile(rules, ruleDir, rulesFile) {
         return {
             name: rule.name,
             path: windsurfPathPosix,
-            content: rule.content,
+            metadata: (0, rules_file_writer_1.parseRuleFrontmatter)(rule.content),
         };
     });
-    const rulesContent = generateRulesFileContent(ruleFiles);
-    writeRulesFile(rulesContent, node_path_1.default.join(process.cwd(), rulesFile));
+    const rulesContent = (0, rules_file_writer_1.generateRulesFileContent)(ruleFiles);
+    (0, rules_file_writer_1.writeRulesFile)(rulesContent, node_path_1.default.join(process.cwd(), rulesFile));
 }
 /**
  * Write all collected rules to their respective IDE targets
@@ -189,6 +117,11 @@ function writeRulesToTargets(rules, targets) {
                     writeRulesForFile(rules, targetPaths.codex, "AGENTS.md");
                 }
                 break;
+            case "claude":
+                if (rules.length > 0) {
+                    writeRulesForFile(rules, targetPaths.claude, "CLAUDE.md");
+                }
+                break;
         }
     }
 }
@@ -245,6 +178,37 @@ function writeMcpServersToFile(mcpServers, mcpPath) {
     };
     fs_extra_1.default.writeJsonSync(mcpPath, mergedConfig, { spaces: 2 });
 }
+function mergeWorkspaceMcpServers(packages) {
+    const merged = {};
+    const info = {};
+    for (const pkg of packages) {
+        for (const [key, value] of Object.entries(pkg.config.mcpServers)) {
+            if (value === false)
+                continue;
+            const json = JSON.stringify(value);
+            if (!info[key]) {
+                info[key] = {
+                    configs: new Set([json]),
+                    packages: [pkg.relativePath],
+                    chosen: pkg.relativePath,
+                };
+            }
+            else {
+                info[key].packages.push(pkg.relativePath);
+                info[key].configs.add(json);
+                info[key].chosen = pkg.relativePath;
+            }
+            merged[key] = value;
+        }
+    }
+    const conflicts = [];
+    for (const [key, data] of Object.entries(info)) {
+        if (data.configs.size > 1) {
+            conflicts.push({ key, packages: data.packages, chosen: data.chosen });
+        }
+    }
+    return { merged, conflicts };
+}
 /**
  * Discover all packages with aicm configurations using git ls-files
  */
@@ -310,17 +274,12 @@ async function installPackage(options = {}) {
             };
         }
         const { config, rules, mcpServers } = resolvedConfig;
-        // Check if rules are defined (either directly or through presets)
-        if (!rules || rules.length === 0) {
-            // If there are no presets defined either, show a message
-            if (!config.presets || config.presets.length === 0) {
-                return {
-                    success: false,
-                    error: new Error("No rules defined in configuration"),
-                    installedRuleCount: 0,
-                    packagesCount: 0,
-                };
-            }
+        if (config.skipInstall === true) {
+            return {
+                success: true,
+                installedRuleCount: 0,
+                packagesCount: 0,
+            };
         }
         try {
             if (!options.dryRun) {
@@ -396,6 +355,9 @@ async function installWorkspaces(cwd, installOnCI, verbose = false, dryRun = fal
         }
         const allPackages = await discoverPackagesWithAicm(cwd);
         const packages = allPackages.filter((pkg) => {
+            if (pkg.config.config.skipInstall === true) {
+                return false;
+            }
             const isRoot = pkg.relativePath === ".";
             if (!isRoot)
                 return true;
@@ -424,6 +386,15 @@ async function installWorkspaces(cwd, installOnCI, verbose = false, dryRun = fal
             verbose,
             dryRun,
         });
+        const { merged: rootMcp, conflicts } = mergeWorkspaceMcpServers(packages);
+        const hasCursorTarget = packages.some((p) => p.config.config.targets.includes("cursor"));
+        if (!dryRun && hasCursorTarget && Object.keys(rootMcp).length > 0) {
+            const mcpPath = node_path_1.default.join(cwd, ".cursor", "mcp.json");
+            writeMcpServersToFile(rootMcp, mcpPath);
+        }
+        for (const conflict of conflicts) {
+            console.warn(`Warning: MCP configuration conflict detected\n  Key: "${conflict.key}"\n  Packages: ${conflict.packages.join(", ")}\n  Using configuration from: ${conflict.chosen}`);
+        }
         if (verbose) {
             result.packages.forEach((pkg) => {
                 if (pkg.success) {
@@ -508,6 +479,9 @@ async function installCommand(installOnCI, verbose, dryRun) {
                 console.log(`Dry run: validated ${rulesInstalledMessage}`);
             }
         }
+        else if (result.installedRuleCount === 0) {
+            console.log("No rules installed");
+        }
         else if (result.packagesCount > 1) {
             console.log(`Successfully installed ${rulesInstalledMessage} across ${result.packagesCount} packages`);
         }

package/dist/utils/config.d.ts

@@ -6,6 +6,7 @@ export interface RawConfig {
     overrides?: Record<string, string | false>;
     mcpServers?: MCPServers;
     workspaces?: boolean;
+    skipInstall?: boolean;
 }
 export interface Config {
     rulesDir?: string;
@@ -14,6 +15,7 @@ export interface Config {
     overrides?: Record<string, string | false>;
     mcpServers?: MCPServers;
     workspaces?: boolean;
+    skipInstall?: boolean;
 }
 export type MCPServer = {
     command: string;
@@ -44,8 +46,8 @@ export interface ResolvedConfig {
     rules: RuleFile[];
     mcpServers: MCPServers;
 }
-export declare const ALLOWED_CONFIG_KEYS: readonly ["rulesDir", "targets", "presets", "overrides", "mcpServers", "workspaces"];
-export declare const SUPPORTED_TARGETS: readonly ["cursor", "windsurf", "codex"];
+export declare const ALLOWED_CONFIG_KEYS: readonly ["rulesDir", "targets", "presets", "overrides", "mcpServers", "workspaces", "skipInstall"];
+export declare const SUPPORTED_TARGETS: readonly ["cursor", "windsurf", "codex", "claude"];
 export type SupportedTarget = (typeof SUPPORTED_TARGETS)[number];
 export declare function detectWorkspacesFromPackageJson(cwd: string): boolean;
 export declare function resolveWorkspaces(config: unknown, configFilePath: string, cwd: string): boolean;

package/dist/utils/config.js

@@ -27,8 +27,14 @@ exports.ALLOWED_CONFIG_KEYS = [
     "overrides",
     "mcpServers",
     "workspaces",
+    "skipInstall",
+];
+exports.SUPPORTED_TARGETS = [
+    "cursor",
+    "windsurf",
+    "codex",
+    "claude",
 ];
-exports.SUPPORTED_TARGETS = ["cursor", "windsurf", "codex"];
 function detectWorkspacesFromPackageJson(cwd) {
     try {
         const packageJsonPath = node_path_1.default.join(cwd, "package.json");
@@ -60,6 +66,7 @@ function applyDefaults(config, workspaces) {
         overrides: config.overrides || {},
         mcpServers: config.mcpServers || {},
         workspaces,
+        skipInstall: config.skipInstall || false,
     };
 }
 function validateConfig(config, configFilePath, cwd, isWorkspaceMode = false) {

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

@@ -1,3 +1,8 @@
+export type RuleMetadata = Record<string, string | boolean | string[]>;
+/**
+ * Parse YAML frontmatter blocks from a rule file and return a flat metadata object
+ */
+export declare function parseRuleFrontmatter(content: string): RuleMetadata;
 /**
  * Write rules to the .windsurfrules file
  * This will update the content between the RULES_BEGIN and RULES_END markers

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

@@ -3,10 +3,55 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRuleFrontmatter = parseRuleFrontmatter;
 exports.writeRulesFile = writeRulesFile;
 exports.generateRulesFileContent = generateRulesFileContent;
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_1 = __importDefault(require("path"));
+/**
+ * Parse YAML frontmatter blocks from a rule file and return a flat metadata object
+ */
+function parseRuleFrontmatter(content) {
+    const metadata = {};
+    // Support both LF and CRLF line endings
+    const frontmatterRegex = /^---\r?\n([\s\S]*?)\r?\n---/gm;
+    let match;
+    while ((match = frontmatterRegex.exec(content)) !== null) {
+        const lines = match[1].split("\n");
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            const [key, ...rest] = trimmed.split(":");
+            if (!key)
+                continue;
+            const raw = rest.join(":").trim();
+            if (raw === "") {
+                metadata[key] = "";
+            }
+            else if (raw === "true" || raw === "false") {
+                metadata[key] = raw === "true";
+            }
+            else if (raw.startsWith("[") && raw.endsWith("]")) {
+                try {
+                    const parsed = JSON.parse(raw.replace(/'/g, '"'));
+                    metadata[key] = parsed;
+                }
+                catch (_a) {
+                    metadata[key] = raw;
+                }
+            }
+            else if ((raw.startsWith('"') && raw.endsWith('"')) ||
+                (raw.startsWith("'") && raw.endsWith("'"))) {
+                metadata[key] = raw.slice(1, -1);
+            }
+            else {
+                metadata[key] = raw;
+            }
+        }
+    }
+    return metadata;
+}
 const RULES_BEGIN = "<!-- AICM:BEGIN -->";
 const RULES_END = "<!-- AICM:END -->";
 const WARNING = "<!-- WARNING: Everything between these markers will be overwritten during installation -->";
@@ -118,7 +163,7 @@ function generateRulesFileContent(ruleFiles) {
     // Agent Requested rules
     if (agentRequestedRules.length > 0) {
         content +=
-            "The following rules are available for the AI to include when needed:\n";
+            "The following rules can be loaded when relevant. Check each file's description:\n";
         agentRequestedRules.forEach((rule) => {
             content += `- ${rule}\n`;
         });

package/package.json

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